大图片文件压缩保存本地，返回本地url

最新推荐文章于 2020-09-17 19:27:43 发布
最新推荐文章于 2020-09-17 19:27:43 发布
阅读量433 收藏
点赞数
分类专栏： Android 文章标签： 图片 压缩 url 保存本地
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cheng900716lihai/article/details/52371264
版权 
import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.os.Build;
import android.os.Environment;
import android.support.v4.util.LruCache;

import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import static android.media.ExifInterface.ORIENTATION_NORMAL;
import static android.media.ExifInterface.ORIENTATION_ROTATE_180;
import static android.media.ExifInterface.ORIENTATION_ROTATE_270;
import static android.media.ExifInterface.ORIENTATION_ROTATE_90;
import static android.media.ExifInterface.TAG_ORIENTATION;

public class ImageFileUtils {
    private static final int widthPixels = 480;
    private static final int heightPixels = 800;
    private static final String PACKAGE_NAME = "com.neobear";
    private static LruCache<String, Bitmap> mAppBitmapCache = null;
    private static Context mContext;

    /**
     * 保存bitmap图片到本地
     *
     * @param filePath
     * @param pathName
     * @param isClearWhenInit
     * @return
     */
    public static String saveBitmap(Context context,String filePath, String pathName, boolean isClearWhenInit) {
        mContext = context;
        Bitmap bitmap = getBitmapWithPath(filePath);

        if (bitmap == null) {
            return "";
        }

        String path = "";
        if (isClearWhenInit) {
            path = getSharePicFile() + pathName;
        } else {
            path = getUploadPicFile() + pathName;
        }
        File file = new File(path);
        if (file.exists()) {
            return path;
        }

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, baos);
        int bitmapSize = baos.toByteArray().length / 2;
        Bitmap cacheBitmap = null;
        double imageSize = bitmapSize / 1024 / 1024;
        // 对可用内存进行判断，来决定压缩策略。。。。需要修改的
        if (imageSize >= 1) {
            cacheBitmap = resizeImage(bitmap, 1080, path);
        } else {
            cacheBitmap = resizeImage(bitmap, path);
        }

        if (cacheBitmap == null) {
            path = "";
        }
        if (cacheBitmap != null && !cacheBitmap.isRecycled()) {
            cacheBitmap.recycle();
        }
        return path;
    }

    /**
     * 文件转换成bitmap
     *
     * @param path
     * @return
     */
    private static Bitmap getBitmapWithPath(String path) {
        Bitmap bmp = null;
        try {
            bmp = ImageFileUtils.readNormalPic(path, widthPixels, heightPixels);
        } catch (OutOfMemoryError e) {
            getBitmapCache().evictAll();
            try {
                bmp = ImageFileUtils.readNormalPic(path, widthPixels, heightPixels);
            } catch (OutOfMemoryError e2) {
            }
        }
        return bmp;
    }

    private static Bitmap readNormalPic(String filePath, int reqWidth, int reqHeight) {
        try {
            if (!isExternalStorageMounted()) {
                return null;
            }

            if (!filePath.endsWith(".jpg") && !filePath.endsWith(".gif") && !filePath.endsWith(".png") && !filePath.endsWith(".jpeg"))
                filePath = filePath + ".jpg";

            boolean fileExist = new File(filePath).exists();

            if (!fileExist) {
                return null;
            }

            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(filePath, options);

            if (reqHeight > 0 && reqWidth > 0)
                options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
            options.inJustDecodeBounds = false;
            options.inPurgeable = true;
            options.inInputShareable = true;

            Bitmap bitmap = BitmapFactory.decodeFile(filePath, options);

            if (bitmap == null) {
                // this picture is broken,so delete it
                new File(filePath).delete();
                return null;
            }

            if (reqHeight > 0 && reqWidth > 0) {
                int[] size = calcResize(bitmap.getWidth(), bitmap.getHeight(), reqWidth, reqHeight);
                if (size[0] > 0 && size[1] > 0) {
                    Bitmap scaledBitmap = Bitmap.createScaledBitmap(bitmap, size[0], size[1], true);
                    if (scaledBitmap != bitmap) {
                        bitmap.recycle();
                        bitmap = scaledBitmap;
                    }
                }
            }

            int exifRotation = ImageFileUtils.getFileExifRotation(filePath);
            if (exifRotation != 0) {
                Matrix mtx = new Matrix();
                mtx.postRotate(exifRotation);
                Bitmap adjustedBitmap = Bitmap.createBitmap(bitmap, 0, 0,
                        bitmap.getWidth(), bitmap.getHeight(), mtx, true);
                if (adjustedBitmap != bitmap) {
                    bitmap.recycle();
                    bitmap = adjustedBitmap;
                }
            }

            return bitmap;
        } catch (OutOfMemoryError ignored) {
            ignored.printStackTrace();
            return null;
        }
    }

    private static synchronized LruCache<String, Bitmap> getBitmapCache() {
        if (mAppBitmapCache == null) {
            buildCache();
        }
        return mAppBitmapCache;
    }

    private static void buildCache() {
        int memClass = ((ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();
        int cacheSize = Math.max(1024 * 1024 * 8, 1024 * 1024 * memClass / 6);

        mAppBitmapCache = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap bitmap) {

                return bitmap.getRowBytes() * bitmap.getHeight();
            }
        };
    }

    private static boolean isExternalStorageMounted() {
        boolean canRead = Environment.getExternalStorageDirectory().canRead();
        boolean onlyRead = Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED_READ_ONLY);
        boolean unMounted = Environment.getExternalStorageState().equals(
                Environment.MEDIA_UNMOUNTED);

        return !(!canRead || onlyRead || unMounted);
    }

    private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {
            if (height > reqHeight && reqHeight != 0) {
                inSampleSize = (int) Math.floor((double) height / (double) reqHeight);
            }

            int tmp = 0;

            if (width > reqWidth && reqWidth != 0) {
                tmp = (int) Math.floor((double) width / (double) reqWidth);
            }

            inSampleSize = Math.max(inSampleSize, tmp);

        }
        int roundedSize;
        if (inSampleSize <= 8) {
            roundedSize = 1;
            while (roundedSize < inSampleSize) {
                roundedSize <<= 1;
            }
        } else {
            roundedSize = (inSampleSize + 7) / 8 * 8;
        }

        return roundedSize;
    }

    private static int[] calcResize(int actualWidth, int actualHeight, int reqWidth, int reqHeight) {
        int height = actualHeight;
        int width = actualWidth;

        float betweenWidth = ((float) reqWidth) / (float) actualWidth;
        float betweenHeight = ((float) reqHeight) / (float) actualHeight;

        float min = Math.min(betweenHeight, betweenWidth);

        height = (int) (min * actualHeight);
        width = (int) (min * actualWidth);

        return new int[]{width, height};
    }

    private static int getFileExifRotation(String filePath) {
        try {
            ExifInterface exifInterface = new ExifInterface(filePath);
            int orientation = exifInterface.getAttributeInt(TAG_ORIENTATION,
                    ORIENTATION_NORMAL);
            switch (orientation) {
                case ORIENTATION_ROTATE_90:
                    return 90;
                case ORIENTATION_ROTATE_180:
                    return 180;
                case ORIENTATION_ROTATE_270:
                    return 270;
                default:
                    return 0;
            }
        } catch (IOException e) {
            return 0;
        }
    }

    private static String getSharePicFile() {
        return sdCardIsExist() ? getSDAccessPath() + "/file/share/" : "/data/data/" + PACKAGE_NAME + "/files/share/";
    }

    private static String getUploadPicFile() {
        return sdCardIsExist() ? getSDAccessPath() + "/file/" : "/data/data/" + PACKAGE_NAME + "/files/";
    }

    /**
     * 判断sdCard的状态
     *
     * @author zhangbp
     */
    private static boolean sdCardIsExist() {
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
    }

    /**
     * 读取sdCard的路径
     *
     * @author zhangbp
     */
    private static String getSDAccessPath() {
        if (sdCardIsExist()) {
            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
                return Environment.getExternalStorageDirectory().getPath() + "/data/" + PACKAGE_NAME;
            } else {
                return mContext.getExternalCacheDir() + "";
            }
        }
        return null;
    }

    private static Bitmap resizeImage(Bitmap bitmap, int w, String filePath) {
        Bitmap BitmapOrg = bitmap;
        int width = BitmapOrg.getWidth();
        int height = BitmapOrg.getHeight();
        int newWidth = 0;
        int newHeight = 0;
        if (width > height) {
            newWidth = w;
            newHeight = (int) (((float) height) / width * w);
        } else {
            newWidth = (int) (((float) width) / height * w);
            newHeight = w;
        }
        // calculate the scale
        float scaleWidth = ((float) newWidth) / width;
        float scaleHeight = ((float) newHeight) / height;
        // create a matrix for the manipulation
        Matrix matrix = new Matrix();
        // resize the Bitmap
        matrix.postScale(scaleWidth, scaleHeight);
        // if you want to rotate the Bitmap
        // matrix.postRotate(readPictureDegree(filePath));
        // recreate the new Bitmap
        Bitmap resizedBitmap = Bitmap.createBitmap(BitmapOrg, 0, 0, width,
                height, matrix, true);
        resizedBitmap = compressImage(resizedBitmap, filePath);
        return resizedBitmap;
    }

    private static Bitmap resizeImage(Bitmap bitmap, String filePath) {
        Bitmap BitmapOrg = bitmap;
        int width = BitmapOrg.getWidth();
        int height = BitmapOrg.getHeight();

        Bitmap resizedBitmap = Bitmap.createBitmap(BitmapOrg, 0, 0, width,
                height, null, true);
        resizedBitmap = compressImage(resizedBitmap, filePath);
        return resizedBitmap;
    }

    private static Bitmap compressImage(Bitmap image, String filePath) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        image.compress(Bitmap.CompressFormat.JPEG, 80, baos);// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
        int options = 100;
        while (baos.toByteArray().length / 1024 > 80) { // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
            if (options >= 10) {
                baos.reset();// 重置baos即清空baos
                image.compress(Bitmap.CompressFormat.JPEG, options, baos);// 这里压缩options%，把压缩后的数据存放到baos中
                options -= 10;// 每次都减少10
            } else {
                break;
            }
        }

        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
        final BitmapFactory.Options ops = new BitmapFactory.Options();
        ops.inJustDecodeBounds = false;
        ops.inPreferredConfig = Bitmap.Config.ARGB_8888;
        ops.inPurgeable = true;//允许可清除
        ops.inInputShareable = true;// 以上options的两个属性必须联合使用才会有效果

        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);// 把ByteArrayInputStream数据生成图片
        try {
            createFile(filePath);
            File file = new File(filePath);
            BufferedOutputStream bos = new BufferedOutputStream(
                    new FileOutputStream(file));
            bitmap.compress(Bitmap.CompressFormat.JPEG, 80, bos);
            bos.flush();
            bos.close();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
        if (image != null && !image.isRecycled()) {
            image.recycle();
        }
        return bitmap;
    }

    private static boolean createFile(String destFileName) {
        File file = new File(destFileName);
        if (!file.getParentFile().exists()) {
            // 如果目标文件所在的目录不存在，则创建父目录
            if (!file.getParentFile().mkdirs()) {
                return false;
            }
        }
        if (destFileName.endsWith(File.separator)) {
            return false;
        }
        // 判断目标文件所在的目录是否存在
        // 创建目标文件
        if (file.exists()) {
            return true;
        }
        try {
            return file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }
}

使用

ImageFileUtils.saveBitmap(context,filepath,filename,false);
Jason@杰森
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
picasso加载图片
追梦赤子的博客
09-18 489
添加配置文件 1.下载路径：picasso-2.5.2.jar的下载路径：https://github.com/square/picasso compile ‘com.squareup.picasso.picasso:2.5.2’ 布局文件 &lt;LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" ...
php 根据URL下载远程图片、压缩包、pdf等文件到本地
10-16
下载远程文件的核心思路是通过HTTP请求获取文件内容，然后将其保存到本地。以下是一个通用的下载函数`downImgRar()`： ```php function downImgRar($url, $rename, $ext){ switch ($ext) { case 'jpg': case '...
以一例教你找到【无水印】【高清】【百度图片】的url
先说一下，就简单地写点儿氵文，不是博客，只是我的笔记本
05-01 3550
笔者举一例来教大家找无水印的高清的百度图片的url 百度搜索"卷积神经网络"： 这是链接: https://baike.baidu.com/item/卷积神经网络 对就是它，点进去即可： 点击右边的卷积神经网络图册，随便选一张照片(就这张还好看一些)： 上面的链接还不是图片的url,我们需要手动找到它，按键盘上的 F12，会出现开发者工具，接下来按如下操作： 点击: 之后将鼠标移动到...
如何通过URL打开图片(Python)
热门推荐
星沉阁
05-08 4万+
不论是用opencv还是PIL，skimage等库，在之前做图像处理的时候，几乎都是读取本地的图片。最近尝试爬虫爬取图片，在保存之前，我希望能先快速浏览一遍图片，然后有选择性的保存。这里就需要从url读取图片了。查了很多资料，发现有这么几种方法，这里做个记录。本文用到的图片URL如下：img_src = 'http://wx2.sinaimg.cn/mw690/ac38503ely1fesz8m0o
20190802 图片url处理
陈如水的专栏
08-02 1168
图片云存储地址头的处理： /** * 通用地址头处理 */ @Autowired private PropertiesConfiguration propertiesConfiguration; public void processImageUrl(){ DoctorDto doctorDto = new DoctorDt...
Android开发网络图片保存到本地指定文件夹
03-01
在Android开发中，将网络图片保存到本地指定文件夹是一个常见的需求，这涉及到网络请求、图片处理和文件操作等技术。下面将详细讲解这个过程，以及如何使用Glide进行图片压缩处理。 首先，我们需要理解Android的...
iOS 读取URL图片并存储到本地的实例
01-20
`UIImageJPEGRepresentation` 将UIImage对象转换为JPEG格式的数据，第二个参数是压缩质量，0.5表示较低的压缩级别，值越小，压缩比例越大，文件体积越小。`writeToFile:atomically:` 将数据写入到指定文件，`...
SpringBoot 实现文件上传到本地目录 并返回可访问的文件地址.rar
05-20
通过以上步骤，我们可以实现一个完整的Spring Boot文件上传服务，将用户上传的文件保存到本地目录，并返回一个可供访问的文件URL。这个过程中涉及的技术包括Spring Boot MVC、文件I/O、安全策略、错误处理等多个方面...
微信小程序多图上传(支持指定压缩大小，带删除按钮)
07-15
7. **服务器端处理**：在服务器端，接收上传的图片文件，通常会将其保存到特定目录，并返回保存成功的标识或文件URL，以便在小程序端展示。 8. **UI设计**：在前端展示方面，可以使用轮播组件（swiper）或者网格...
java实现文件上传到FTP和从FTP下载到本地功能
02-26
java实现文件上传到FTP和从FTP下载到本地功能，里面没有jar架包，但有说明要哪些架包
图片url地址的生成获取方法
weixin_30918415的博客
05-20 5604
　　在写博客插入图片时，许多时候需要提供图片的url地址。作为菜鸡的我，自然是一脸懵逼。那么什么是所谓的url地址呢？又该如何获取图片的url地址呢？ 　　首先来看一下度娘对url地址的解释：url是统一资源定位符，对可以从互联网上得到的资源的位置和访问方法的一种简洁的表示，是互联网上标准资源的地址。互联网上的每个文件都有一个唯一的url，它包含的信息指出文件的位置以及浏览器应该怎么处理它。 ...
下载zip文件并保存到本地(JAVA)
qq_42667717的博客
09-17 4149
此篇博客为从服务器下载zip文件然后保存到本地的记录; 1,文件下载步骤: （1）通过统一资源定位器（java.net.URL）获取连接器（java.net.URLConnection）。 （2）通过HttpURLConnection设置请求参数,并发送请求,然后获取一个返 回的输入流。 （3）建立存储的目录以及保存的文件名。 （4）建立输出流并写入数据。 （5）关闭输入流和输出流。 2,代码实现: public class HttpConnectionUtil { private stati
图片异步压缩保存到本地文件PhotoCompress
Fly_o0o的专栏
02-27 1494
今天移植了一个图片压缩保存到本地文件的demo，希望有帮到有需要的同学。 项目不难，就是异步压缩选择的图片并保存到本地文件的功能，方法也挺简单的，移植出来就是为了以后集成快速方便。 工程目录如上，压缩的功能主要在ImageUtils和UriImage这两个类里面，MediaFile是一个判断文件的工具类，防止选择了非图片的文件。 在ImageUtils类中可以设置压缩后的最大宽、高和文件
Android 图片质量压缩小记
dhl_1986的博客
12-19 348
   对于图片的处理，几乎是最普通的需求了，上传图片，图片拷贝，但是往往本地图片会比较大，这个时候就需要压缩处理了，总不能把一张几兆的图片上传给服务器吧，这个是完全没必要的。 1，图片保存文件  /** * 处理 bitmap,把一张很大的图片压缩到另外一个目录 */ private void handleBitmap() { String...
网上图片本地保存并进行压缩操作
qq_30401659的博客
05-02 643
package com.demo.wnb; import java.awt.Graphics2D; import java.awt.Image; import java.awt.image.BufferedImage; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream
Java实现一个文件上传到本地服务器的业务
最新发布
09-04
在保存文件的过程中，也可以根据需要对文件进行一些处理，例如修改文件名、压缩文件等。 3. 部署该Servlet到Web服务器中，启动Web服务器，访问该Servlet对应的URL即可上传文件。 ### 回答2： 要实现Java文件上传...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值