图片处理 on 进制动态

Python 修改图片分辨率（单张/批量/等比例/递归覆盖）

Thu, 23 Apr 2026 19:35:00 +0800

1. 修改单张图片分辨率

from PIL import Image

def resize_image(input_image_path, output_image_path, new_width, new_height):
    image = Image.open(input_image_path)
    resized_image = image.resize((new_width, new_height))
    resized_image.save(output_image_path)

# 使用示例
input_image_path = "input.jpg"
output_image_path = "output.jpg"
new_width = 800
new_height = 600

resize_image(input_image_path, output_image_path, new_width, new_height)

2. 批量修改文件夹内所有图片分辨率

import os
from PIL import Image

def resize_images_in_folder(input_folder, output_folder, new_width, new_height):
    for filename in os.listdir(input_folder):
        if filename.endswith(".jpg") or filename.endswith(".png"):
            input_image_path = os.path.join(input_folder, filename)
            output_image_path = os.path.join(output_folder, filename)
            resize_image(input_image_path, output_image_path, new_width, new_height)

def resize_image(input_image_path, output_image_path, new_width, new_height):
    image = Image.open(input_image_path)
    resized_image = image.resize((new_width, new_height))
    resized_image.save(output_image_path)

# 使用示例
input_folder = "input_folder"
output_folder = "output_folder"
new_width = 800
new_height = 600

resize_images_in_folder(input_folder, output_folder, new_width, new_height)

3. 等比例修改图片分辨率

from PIL import Image

def resize_image(input_path, output_path, new_width, new_height):
    image = Image.open(input_path)
    width, height = image.size
    aspect_ratio = width / height

    if new_width is None:
        new_width = int(new_height * aspect_ratio)
    elif new_height is None:
        new_height = int(new_width / aspect_ratio)

    resized_image = image.resize((new_width, new_height), Image.ANTIALIAS)
    resized_image.save(output_path)

if __name__ == "__main__":
    input_path = "input.jpg"
    output_path = "output.jpg"
    new_width = 800
    new_height = None

    resize_image(input_path, output_path, new_width, new_height)

4. 递归等比例修改并覆盖原图

import os
from PIL import Image

def resize_image(input_path, new_width, new_height):
    image = Image.open(input_path)
    width, height = image.size
    aspect_ratio = width / height

    if new_width is None:
        new_width = int(new_height * aspect_ratio)
    elif new_height is None:
        new_height = int(new_width / aspect_ratio)

    resized_image = image.resize((new_width, new_height), Image.ANTIALIAS)
    resized_image.save(input_path)

def resize_images_in_directory(directory, new_width, new_height):
    for root, dirs, files in os.walk(directory):
        for filename in files:
            if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
                input_path = os.path.join(root, filename)
                resize_image(input_path, new_width, new_height)

if __name__ == "__main__":
    target_directory = "your_directory_path"
    new_width = 800
    new_height = None

    resize_images_in_directory(target_directory, new_width, new_height)

使用说明

安装依赖：pip install pillow
根据需求选择对应脚本
修改文件路径、宽度、高度参数
直接运行即可
支持格式：jpg、jpeg、png、gif

Android开发：权限处理、文件存储、图片处理常用代码

Wed, 22 Apr 2026 19:00:00 +0800

一、权限处理代码

以外部存储写入权限为例，适配Android 6.0+动态权限。

1. 权限申请方法

private void requestWritePermission(){
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        if(checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},WRITE_PERMISSION);
        }
    }
}

2. 权限结果回调

@Override
public void onRequestPermissionsResult(
        int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == Permission.REQUEST_CODE) {
        for (int grantResult : grantResults) {
            if (grantResult != PackageManager.PERMISSION_GRANTED) {
                Log.e("Permission","授权失败！");
                // 授权失败，退出应用
                this.finish();
                return;
            }
        }
    }
}

3. 在 onCreate 中调用

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    requestWritePermission();
}

二、文件存储工具类（FileUtils）

包含文件创建、删除、复制、Bitmap 转字节、MD5、数据库备份等常用方法。

import android.content.Context;
import android.graphics.Bitmap;
import android.os.Environment;
import android.text.TextUtils;
import android.util.Log;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class FileUtils {

    private String TAG = FileUtils.class.getSimpleName();
    public static String SDPATH = Environment.getExternalStorageDirectory() + "/.photocomb/";
    public static String DBName = "privalbum.db";
    public static String DBPATH = "/data/data/com.cm.photocomb/databases/" + DBName;

    /**
     * 操作成功返回值
     */
    public static final int SUCCESS = 0;

    /**
     * 操作失败返回值
     */
    public static final int FAILED = -1;

    private static final int BUF_SIZE = 32 * 1024; // 32KB

    /**
     * 获取录音文件路径
     */
    public static String getFileName() {
        String path = SDPATH;
        File file = new File(path);
        file.mkdirs();
        path += System.currentTimeMillis();
        return path;
    }

    /**
     * Bitmap转字节数组
     */
    public static byte[] Bitmap2Bytes(Bitmap bm) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        bm.compress(Bitmap.CompressFormat.PNG, 100, baos);
        return baos.toByteArray();
    }

    /**
     * bytes转十六进制字符串
     */
    public static String byte2HexStr(byte[] b) {
        String stmp = "";
        StringBuilder sb = new StringBuilder("");
        for (int n = 0; n < b.length; n++) {
            stmp = Integer.toHexString(b[n] & 0xFF);
            sb.append((stmp.length() == 1) ? "0" + stmp : stmp);
            sb.append(" ");
        }
        return sb.toString().toUpperCase().trim();
    }

    /**
     * 十六进制字符串转byte数组
     */
    public static byte[] hexStr2Bytes(String src) {
        int m = 0, n = 0;
        int l = src.length() / 2;
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            m = i * 2 + 1;
            n = m + 1;
            ret[i] = Byte.decode("0x" + src.substring(i * 2, m) + src.substring(m, n));
        }
        return ret;
    }

    public static String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);
            if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }
        return sb.toString();
    }

    private static final char HEX_DIGITS[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

    public static String toHexString(byte[] b) {
        StringBuilder sb = new StringBuilder(b.length * 2);
        for (int i = 0; i < b.length; i++) {
            sb.append(HEX_DIGITS[(b[i] & 0xf0) >>> 4]);
            sb.append(HEX_DIGITS[b[i] & 0x0f]);
        }
        return sb.toString();
    }

    /**
     * 计算文件MD5值
     */
    public static String md5sum(String filename) {
        if (TextUtils.isEmpty(filename)) {
            return null;
        }
        InputStream fis;
        byte[] buffer = new byte[1024];
        int numRead = 0;
        MessageDigest md5;
        try {
            fis = new FileInputStream(filename);
            md5 = MessageDigest.getInstance("MD5");
            while ((numRead = fis.read(buffer)) > 0) {
                md5.update(buffer, 0, numRead);
            }
            fis.close();
            return toHexString(md5.digest());
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 保存Bitmap到文件
     */
    public static void saveBitmap(Bitmap bm, String picName) {
        Log.e("", "保存图片");
        try {
            File f = new File(picName);
            if (f.exists()) {
                f.delete();
            }
            FileOutputStream out = new FileOutputStream(f);
            if (bm != null) {
                bm.compress(Bitmap.CompressFormat.JPEG, 90, out);
            }
            out.flush();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static boolean saveBitmap(Bitmap bitmap, File file) {
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        if (file.exists()) {
            file.delete();
        }
        FileOutputStream out = null;
        try {
            out = new FileOutputStream(file);
            bitmap.compress(Bitmap.CompressFormat.JPEG, 90, out);
            out.flush();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
            return false;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }

    /**
     * 创建SD卡目录
     */
    public static File createSDDir(String dirName) throws IOException {
        File dir = new File(SDPATH + dirName);
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            dir.mkdir();
        }
        return dir;
    }

    /**
     * 判断文件是否存在
     */
    public static boolean isFileExist(String fileName) {
        File file = new File(SDPATH + fileName);
        return file.exists();
    }

    /**
     * 删除文件
     */
    public static void delFile(String fileName) {
        File file = new File(SDPATH + fileName);
        if (file.isFile()) {
            file.delete();
        }
    }

    /**
     * 删除目录及子文件
     */
    public static void deleteDir() {
        File dir = new File(SDPATH);
        if (dir == null || !dir.exists() || !dir.isDirectory())
            return;

        for (File file : dir.listFiles()) {
            if (file.isFile())
                file.delete();
            else if (file.isDirectory())
                deleteDir();
        }
        dir.delete();
    }

    public static boolean fileIsExists(String path) {
        try {
            File f = new File(path);
            return f.exists();
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 删除单个文件
     */
    public static boolean deleteFile(String sPath) {
        File file = new File(sPath);
        if (file.isFile() && file.exists()) {
            file.delete();
            return true;
        }
        return false;
    }

    /**
     * 删除目录及目录下所有文件
     */
    public static boolean deleteDirectory(String sPath) {
        if (TextUtils.isEmpty(sPath)) {
            return false;
        }
        if (!sPath.endsWith(File.separator)) {
            sPath = sPath + File.separator;
        }
        File dirFile = new File(sPath);
        if (!dirFile.exists() || !dirFile.isDirectory()) {
            return false;
        }
        boolean flag = true;
        File[] files = dirFile.listFiles();
        for (File file : files) {
            if (file.isFile()) {
                flag = deleteFile(file.getAbsolutePath());
                if (!flag) break;
            } else {
                flag = deleteDirectory(file.getAbsolutePath());
                if (!flag) break;
            }
        }
        if (!flag) return false;
        return dirFile.delete();
    }

    /**
     * 文件转字节数组
     */
    public static byte[] getBytesFromFile(File f) {
        if (f == null) {
            return null;
        }
        try {
            FileInputStream stream = new FileInputStream(f);
            ByteArrayOutputStream out = new ByteArrayOutputStream(1000);
            byte[] b = new byte[1000];
            int n;
            while ((n = stream.read(b)) != -1) {
                out.write(b, 0, n);
            }
            stream.close();
            out.close();
            return out.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 字节数组保存为文件
     */
    public static File getFileFromBytes(byte[] b, String outputFile) {
        BufferedOutputStream stream = null;
        File file = null;
        try {
            file = new File(outputFile);
            FileOutputStream fstream = new FileOutputStream(file);
            stream = new BufferedOutputStream(fstream);
            stream.write(b);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (stream != null) {
                try {
                    stream.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
            }
        }
        return file;
    }

    /**
     * 备份数据库
     */
    public static void backupDB(Context mContext) {
        try {
            File backup = new File(SDPATH + DBName);
            File dbFile = mContext.getDatabasePath(DBPATH);
            backup.createNewFile();
            fileCopy(dbFile, backup);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 文件复制
     */
    public static void fileCopy(File dbFile, File backup) throws IOException {
        FileChannel inChannel = new FileInputStream(dbFile).getChannel();
        FileChannel outChannel = new FileOutputStream(backup).getChannel();
        try {
            inChannel.transferTo(0, inChannel.size(), outChannel);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inChannel != null) {
                inChannel.close();
            }
            if (outChannel != null) {
                outChannel.close();
            }
        }
    }

    /**
     * assets文件复制到本地
     */
    public static int assetToFile(Context context, String assetName, String path) {
        return assetToFile(context, assetName, new File(path));
    }

    public static int assetToFile(Context context, String assetName, File file) {
        InputStream is = null;
        try {
            is = context.getAssets().open(assetName);
            return streamToFile(file, is, false);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) is.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return FAILED;
    }

    /**
     * 流写入文件
     */
    public static int streamToFile(String path, InputStream is, boolean isAppend) {
        return streamToFile(new File(path), is, isAppend);
    }

    public static int streamToFile(File file, InputStream is, boolean isAppend) {
        checkParentPath(file);
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file, isAppend);
            byte[] buf = new byte[BUF_SIZE];
            int readSize;
            while ((readSize = is.read(buf)) != -1)
                fos.write(buf, 0, readSize);
            fos.flush();
            return SUCCESS;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) fos.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return FAILED;
    }

    /**
     * 检查并创建父目录
     */
    public static void checkParentPath(String path) {
        checkParentPath(new File(path));
    }

    public static void checkParentPath(File file) {
        File parent = file.getParentFile();
        if (parent != null && !parent.isDirectory())
            createDir(parent);
    }

    /**
     * 创建文件夹
     */
    public static int createDir(String path) {
        return createDir(new File(path));
    }

    public static int createDir(File file) {
        if (file.exists()) {
            if (file.isDirectory())
                return SUCCESS;
            file.delete();
        }
        if (file.mkdirs())
            return SUCCESS;
        return FAILED;
    }
}

三、图片处理工具类（XUtils）

包含图片压缩、旋转纠正、获取缩略图、Bitmap 保存、网络判断、内存获取等。

import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.BitmapFactory;
import android.graphics.BitmapFactory.Options;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.text.TextUtils;
import android.util.Log;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;

public class XUtils {

    /**
     * 判断文件是否存在
     */
    public static Boolean fileExists(String vPath) {
        if (null == vPath || "".equals(vPath)) {
            return false;
        }
        try {
            File file = new File(vPath);
            return file.exists();
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * 计算图片缩放比例
     */
    public static int calculateInSampleSize(Options options, int maxWidth, int maxHeight) {
        int inSampleSize = 1;
        final int height = options.outHeight;
        final int width = options.outWidth;
        int minhw = Math.min(height, width);

        if (minhw >= maxWidth) {
            inSampleSize = Math.round((float) width / (float) maxWidth);
            while (minhw / inSampleSize > maxWidth) {
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }

    /**
     * 获取图片缩略图（带旋转纠正）
     */
    public static Bitmap getThumbImg(String vPath, int vWidth, int vHeight) {
        if (null == vPath || vPath.trim().equals("")) {
            return null;
        }
        File file = new File(vPath);
        if (!file.exists()) {
            return null;
        }
        Options options = new Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(vPath, options);
        if (options.outWidth <= 0 || options.outHeight <= 0) {
            return null;
        }
        options.inSampleSize = calculateInSampleSize(options, vWidth, vHeight);
        options.inJustDecodeBounds = false;
        Bitmap thumbImgNow = null;
        try {
            thumbImgNow = BitmapFactory.decodeFile(vPath, options);
        } catch (OutOfMemoryError e) {
            return null;
        }
        int degree = readPictureDegree(vPath);
        if (degree != 0) {
            thumbImgNow = rotateImage(degree, thumbImgNow);
        }
        return thumbImgNow;
    }

    /**
     * 旋转图片
     */
    public static Bitmap rotateImage(int angle, Bitmap bitmap) {
        if (null == bitmap) {
            return null;
        }
        Matrix matrix = new Matrix();
        matrix.postRotate(angle);
        try {
            return Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
        } catch (OutOfMemoryError e) {
            return bitmap;
        }
    }

    /**
     * 读取图片旋转角度
     */
    public static int readPictureDegree(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            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;
    }

    /**
     * 字节数组保存到文件
     */
    public static Boolean saveByteToFile(byte[] vData, String vFilePath) {
        if (null == vData || TextUtils.isEmpty(vFilePath)) {
            return false;
        }
        File tFile = new File(vFilePath);
        try {
            FileOutputStream fos = new FileOutputStream(tFile);
            fos.write(vData);
            fos.close();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 从文件读取字节数组
     */
    public static byte[] loadByteFromFile(String vFilePath, int vLen) {
        if (TextUtils.isEmpty(vFilePath) || vLen < 1) {
            return null;
        }
        File tFile = new File(vFilePath);
        byte[] tByte = new byte[vLen];
        try (FileInputStream fin = new FileInputStream(tFile)) {
            int r = fin.read(tByte);
            if (r != vLen) {
                throw new IOException("Can't read all");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return tByte;
    }

    /**
     * 保存Bitmap到本地
     */
    public static Boolean saveBitmap(Bitmap vBmp, String vPath) {
        if (null == vBmp || vBmp.isRecycled() || TextUtils.isEmpty(vPath)) {
            return false;
        }
        File file = new File(vPath).getParentFile();
        if (!file.exists()) {
            file.mkdirs();
        }
        try {
            FileOutputStream fout = new FileOutputStream(vPath);
            BufferedOutputStream bos = new BufferedOutputStream(fout);
            vBmp.compress(Bitmap.CompressFormat.JPEG, 100, bos);
            bos.flush();
            bos.close();
            return true;
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 判断网络是否连接
     */
    public static Boolean isNetworkConnected(Context context) {
        if (context != null) {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
            return mNetworkInfo != null && mNetworkInfo.isAvailable();
        }
        return false;
    }

    /**
     * 获取可用内存
     */
    public static long getmem_UNUSED(Context mContext) {
        ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
        ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
        am.getMemoryInfo(mi);
        return mi.availMem / 1024;
    }

    /**
     * Bitmap拷贝（防内存溢出）
     */
    public static Bitmap bmpcopy(Bitmap srcBmp) {
        Bitmap destBmp = null;
        try {
            File file = new File("/mnt/sdcard/tempbmp/tmp.txt");
            file.getParentFile().mkdirs();
            RandomAccessFile randomAccessFile = new RandomAccessFile(file, "rw");
            int width = srcBmp.getWidth();
            int height = srcBmp.getHeight();
            FileChannel channel = randomAccessFile.getChannel();
            MappedByteBuffer map = channel.map(MapMode.READ_WRITE, 0, (long) width * height * 4);
            srcBmp.copyPixelsToBuffer(map);
            srcBmp.recycle();
            destBmp = Bitmap.createBitmap(width, height, Config.ARGB_8888);
            map.position(0);
            destBmp.copyPixelsFromBuffer(map);
            channel.close();
            randomAccessFile.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return destBmp;
    }

    /**
     * 等比缩放图片（按最小边缩放）
     */
    public static Bitmap getScaledBitmap(String vPath, int vMinWidth) {
        if (null == vPath || vPath.trim().equals("")) {
            return null;
        }
        File file = new File(vPath);
        if (!file.exists()) {
            return null;
        }
        Options options = new Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(vPath, options);
        if (options.outWidth <= 0 || options.outHeight <= 0) {
            return null;
        }
        int tMinWidth = Math.min(options.outWidth, options.outHeight);
        options.inSampleSize = Math.max(1, tMinWidth / vMinWidth);
        options.inJustDecodeBounds = false;
        Bitmap thumbImgNow = null;
        try {
            thumbImgNow = BitmapFactory.decodeFile(vPath, options);
        } catch (OutOfMemoryError e) {
            return null;
        }
        int degree = readPictureDegree(vPath);
        if (degree != 0) {
            thumbImgNow = rotateImage(degree, thumbImgNow);
        }
        int wid = thumbImgNow.getWidth();
        int hgt = thumbImgNow.getHeight();
        tMinWidth = Math.min(wid, hgt);
        if (tMinWidth > vMinWidth) {
            float ratio = ((float) vMinWidth) / tMinWidth;
            Matrix matrix = new Matrix();
            matrix.postScale(ratio, ratio);
            thumbImgNow = Bitmap.createBitmap(thumbImgNow, 0, 0, wid, hgt, matrix, true);
        }
        return thumbImgNow;
    }
}

说明

代码适配Android 6.0+，存储权限需动态申请。
文件存储路径、包名可根据项目自行修改。
图片处理已做OOM 防护与旋转自动纠正。