精华内容
下载资源
问答
  • 图片压缩处理工具

    2011-10-01 20:52:37
    图片压缩处理工具;图片放大不失真。快速调整图片大小的工具。
  • 一个图片压缩处理工具
  • 目前上传的是64位滴,32位的下次发吧,图片压缩工具,找了好久的,可处理png和jpg,可有损可无损,压缩速度快,并且免费
  • 批量处理图片的格式,大小,可以做到压缩图片大小。分辨率等
  • Thumbnails是google公司开源的图片压缩处理工具,可以对图片按大小或比例缩放、旋转、加水印、裁剪等。 1、pom.xml引入 <!--图片压缩工具--> <dependency> <groupId>net.coobird</...

    Thumbnails是google公司开源的图片压缩、处理的工具,可以对图片按大小或比例缩放、旋转、加水印、裁剪等。

    1、pom.xml引入

    
      <!--图片压缩工具-->
        <dependency>
          <groupId>net.coobird</groupId>
          <artifactId>thumbnailator</artifactId>
          <version>0.4.12</version>
        </dependency>

    2、springMVC上传文件压缩处理(示例代码)

    @RequestMapping(value = "/upload",method = RequestMethod.POST)
    public RetMsg upload(@RequestParam(value = "file",required = false)
                                  MultipartFile file) throws Exception{
       if(file==null || file.getSize()==0){
           return RetMsg.failure("上传文件不能为空");
       }
       String orgFileName = file.getOriginalFilename();
       String contentType =file.getContentType();//文件的contentType
     
       byte[] bytes=null;//字节数据
       
       if(file.getSize()>=1024*1024*10){ //10M
            return RetMsg.failure("上传文件太大,不得超过10M");
       }
       if(file.getSize()>4*1024*1024){//4M  如果图片大于4M进行压缩处理
           InputStream in=file.getInputStream();
           ByteArrayOutputStream out =new ByteArrayOutputStream(1024*1024);
           Thumbnails.of(in).scale(0.5,0.5).outputQuality(1.0).toOutputStream(out);//将图片进行压缩 0.5*0.5
           bytes=out.toByteArray();
       }else{
           bytes=file.getBytes();
       }
     
    uploadService.uploadFile(bytes);
        return RetMsg.success() ;
     
    }

     

    展开全文
  • 图片压缩处理工具

    2020-12-10 11:34:19
    a>关于图片压缩需要考虑如下因素: b>图片的大小(M)限制 c>图片尺寸(宽高)限制 c>图片(大小、尺寸)不需要处理 e>图片清晰度与大小、尺寸的矛盾处理 f>Spring中MultipartFile与原生File的转化及byte字符流处理
    前言:
    关于图片压缩需要考虑如下因素:
    b>图片的大小(M)限制
    c>图片尺寸(宽高)限制
    c>图片(大小、尺寸)不需要处理
    e>图片清晰度与大小、尺寸的矛盾处理
    f>Spring中MultipartFile与原生File的转化及byte字符流处理 
    
    

    1.压缩处理工具类如下:
    
    package com.worm.util;
    
    import com.ding.framwork.util.secure.MD5Tool;
    import net.coobird.thumbnailator.Thumbnails;
    import org.apache.commons.io.FileUtils;
    import org.apache.commons.io.IOUtils;
    import org.apache.commons.lang.StringUtils;
    import org.apache.http.entity.ContentType;
    import org.springframework.mock.web.MockMultipartFile;
    import org.springframework.web.multipart.MultipartFile;
    
    import javax.imageio.ImageIO;
    import java.awt.*;
    import java.awt.geom.AffineTransform;
    import java.awt.image.AffineTransformOp;
    import java.awt.image.BufferedImage;
    import java.io.*;
    import java.nio.file.Files;
    import java.util.UUID;
    
    /**
     * 图片处理工具类
     * @author learnworm
     * @version 2020-12-10 上午10:07:13
     */
    public class ImageUtil {
        //默认素材宽
        private final static int DEFAULT_MATERIAL_IMG_WIDTH = 1280;
        //默认素材高
        private final static int DEFAULT_MATERIAL_IMG_HEIGHT = 1920;
    	//默认大小限制(1M)
    	private final static long DEFAULT_MATERIAL_IMG_SIZE = 1024*1024;
    
    	 public static void main(String[] args) throws  IOException{
    		String path1 = "D:\\tmp\\mu3.jpg";
    		File file = new File(path1);
    		MultipartFile multipartFile = filtToMuti(file);
    		String materialUrl = multipartFile.getOriginalFilename();
    		byte[] bytes = ImageUtil.imgCompress(multipartFile);
    		String digest = MD5Tool.getFileMD5(ImageUtil.byteToFile(bytes, ImageUtil.getSufix(materialUrl)));
    		writeFile(bytes, "D:\\tmp\\sub", materialUrl);
    		System.out.println("--------1----------^"+digest+"====="+materialUrl);
    	}
    
    	/**
    	 * 文件Md5签名
    	 * @param bytes
    	 * @param originalUrl
    	 * @return
    	 */
    	public static String digistMd5(byte[] bytes,String originalUrl){
    		try {
    			return MD5Tool.getFileMD5(ImageUtil.byteToFile(bytes, ImageUtil.getSufix(originalUrl)));
    		}catch (IOException ioe){
    			ioe.printStackTrace();
    			return null;
    		}
    	}
    
    	/**
    	 * 图片压缩处理
    	 * @param mutiFile
    	 * @return
    	 */
    	public static byte[] imgCompress(MultipartFile mutiFile){
    		byte[] bytes = null;
    		//转File类型文件
    	 	File file = mutiToFile(mutiFile);
    		//图片后缀
    		String sufix = getSufix(mutiFile.getName());
    		//图片大小
    		long len = mutiFile.getSize();
    		//图片尺寸
    		boolean size = isResize(file,DEFAULT_MATERIAL_IMG_WIDTH,DEFAULT_MATERIAL_IMG_HEIGHT);
    		try {
    			File rfile = null;
    			bytes = mutiFile.getBytes();
    			if(size){//限制尺寸大小
    				BufferedImage bimg = imgCompressResize(file,DEFAULT_MATERIAL_IMG_WIDTH,DEFAULT_MATERIAL_IMG_HEIGHT);
    				String bName = UUID.randomUUID().toString();
    				File tmpDirFile = Files.createTempDirectory("tempFile").toFile();
    				rfile = File.createTempFile(bName, sufix, tmpDirFile);
    				ImageIO.write(bimg, getSufix(mutiFile.getName()), rfile);
    				bytes = getImgBytes(rfile);
    				//重新计算大小
    				mutiFile = byteToMuti(bytes);
    				len = mutiFile.getSize();
    			}
    			if(len>DEFAULT_MATERIAL_IMG_SIZE){//保持清晰度
    				bytes = imgCompressQuality(mutiFile.getBytes(),DEFAULT_MATERIAL_IMG_SIZE,sufix);
    				//重新计算大小
    				mutiFile = byteToMuti(bytes);
    				len = mutiFile.getSize();
    			}
    			if(len>DEFAULT_MATERIAL_IMG_SIZE){//严格限制到指定大小
    				bytes = imgCompressLen(mutiFile.getBytes(),DEFAULT_MATERIAL_IMG_SIZE,sufix);
    			}
    			if(rfile!=null && rfile.exists()){
    				rfile.delete();
    			}
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return bytes;
    	}
    
    	/**
    	 * 图片压缩算法-清淅度
    	 * @param input
    	 * @param maxLen 最大
    	 * @return
    	 * @throws IOException
    	 */
    	public static byte[] imgCompressQuality(byte[] input,long maxLen,String sufix) throws IOException {
    		if(input.length < maxLen){
    			return input;
    		}
    		if (StringUtils.isEmpty(sufix)){//如果空则默认jpg
    			sufix = "jpg";
    		}
    		float quality = 1.0f;
    		float scale = 1.0f;
    		ByteArrayOutputStream os = new ByteArrayOutputStream();
    		InputStream is = new ByteArrayInputStream(input);
    		Thumbnails.of(is).scale(scale).outputQuality(quality).outputFormat(sufix).toOutputStream(os);
    		byte[] result = os.toByteArray();
    		while(result.length > maxLen && quality > 0.399){//保清晰度
    			is.close();
    			is = new ByteArrayInputStream(input);
    			os.close();
    			os = new ByteArrayOutputStream();
    			quality = quality - 0.05f;
    			Thumbnails.of(is).scale(scale).outputQuality(quality).outputFormat(sufix).toOutputStream(os);
    			result = os.toByteArray();
    		}
    		return result;
    	}
    
    	/**
    	 * 图片压缩-大小M
    	 * @param input
    	 * @param maxLen 大小
    	 * @return
    	 * @throws IOException
    	 */
    	public static byte[] imgCompressLen(byte[] input,long maxLen,String sufix) throws IOException {
    		if(input.length < maxLen){
    			return input;
    		}
    		if (StringUtils.isEmpty(sufix)){//如果空则默认jpg
    			sufix = "jpg";
    		}
    		float quality = 1.0f;
    		float scale = 1.0f;
    		ByteArrayOutputStream os = new ByteArrayOutputStream();
    		InputStream is = new ByteArrayInputStream(input);
    		Thumbnails.of(is).scale(scale).outputQuality(quality).outputFormat(sufix).toOutputStream(os);
    		byte[] result = os.toByteArray();
    		while(result.length > maxLen){//限制大小
    			is.close();
    			is = new ByteArrayInputStream(input);
    			os.close();
    			os = new ByteArrayOutputStream();
    			quality = quality - 0.05f;
    			Thumbnails.of(is).scale(scale).outputQuality(quality).outputFormat(sufix).toOutputStream(os);
    			result = os.toByteArray();
    			byte[] tmpbyte = os.toByteArray();
    		}
    		return result;
    	}
    
    	/**
    	 * @desc 图片缩放
    	 * @param file 图片
    	 * @param defWidth 宽度
    	 * @param defHeight 高度
    	 */
    	public static BufferedImage imgCompressResize(File file, int defWidth, int defHeight) {
    		try {
    			double ratio = 1; // 缩放比例
    			BufferedImage bi = ImageIO.read(file);
    			Image itemp = bi.getScaledInstance(defWidth, defHeight,Image.SCALE_SMOOTH);
    			int imgWidth = bi.getWidth();
    			int imgHeight = bi.getHeight();
    			//宽高需要处理
    			if(imgWidth > defWidth && imgHeight > defHeight) {
    				double ratioW = (new Integer(defWidth)).doubleValue()/imgWidth;
    				double ratioH = (new Integer(defHeight)).doubleValue()/imgHeight;
    				if(ratioW < ratioH) {
    					ratio = ratioW;
    				}else {
    					ratio = ratioH;
    				}
    				AffineTransformOp op = new AffineTransformOp(AffineTransform.getScaleInstance(ratio, ratio), null);
    				itemp = op.filter(bi, null);
    			}
    			return (BufferedImage) itemp;
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * @desc 图片缩放
    	 * @param file 图片
    	 * @param defWidth 宽度
    	 * @param defHeight 高度
    	 * @return boolean
    	 */
    	public static boolean isResize(File file, int defWidth, int defHeight) {
    		try {
    			BufferedImage bi = ImageIO.read(file);
    			int imgWidth = bi.getWidth();
    			int imgHeight = bi.getHeight();
    			//宽高是否符合要求
    			if(imgWidth > defWidth && imgHeight > defHeight) {
    				return true;
    			}
    			return false;
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		return false;
    	}
    
    	/**
    	 * 图片补白
    	 * @param file 图片
    	 * @param defWidth 宽
    	 * param  defHeight 高
    	 */
    	public static BufferedImage imgFiller(File file, int defWidth, int defHeight) {
    		try {
    			BufferedImage bi = ImageIO.read(file);
    			Image itemp = bi.getScaledInstance(defWidth, defHeight,Image.SCALE_SMOOTH);
    			int imgWidth = bi.getWidth();
    			int imgHeight = bi.getHeight();
    			BufferedImage image = new BufferedImage(defWidth, defHeight,
    					BufferedImage.TYPE_INT_RGB);
    			Graphics2D g = image.createGraphics();
    			g.setColor(Color.white);
    			g.fillRect(0, 0, defWidth, defHeight);
    			if (defWidth == itemp.getWidth(null))
    				g.drawImage(itemp, 0, (defHeight - itemp.getHeight(null)) / 2,
    						itemp.getWidth(null), itemp.getHeight(null),
    						Color.white, null);
    			else
    				g.drawImage(itemp, (defWidth - itemp.getWidth(null)) / 2, 0,
    						itemp.getWidth(null), itemp.getHeight(null),
    						Color.white, null);
    			g.dispose();
    			itemp = image;
    			return (BufferedImage) itemp;
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * 得到文件字节流
    	 * @param file
    	 * @return
    	 */
    	public static byte[] getImgBytes(File file){
    		byte[] buffer = null;
    		try {
    			FileInputStream fis = new FileInputStream(file);
    			ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
    			byte[] b = new byte[1000];
    			int n;
    			while ((n = fis.read(b)) != -1) {
    				bos.write(b, 0, n);
    			}
    			fis.close();
    			bos.close();
    			buffer = bos.toByteArray();
    		} catch (FileNotFoundException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    		return buffer;
    	}
    
    	/**
    	 * @desc 字节流转文件
    	 * @param bytes
    	 * @param ext
    	 * @return
    	 * @throws IOException
    	 */
    	public static File byteToFile(byte[] bytes,String ext) throws IOException {
    		ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
    		String fileName = UUID.randomUUID().toString();
    		File tmpDirFile = Files.createTempDirectory("tempFile").toFile();
    		File resultFile = File.createTempFile(fileName, '.' + ext, tmpDirFile);
    		resultFile.deleteOnExit();
    		org.apache.commons.io.FileUtils.copyInputStreamToFile(inputStream, resultFile);
    		return resultFile;
    	}
    
    	/**
    	 * 生成文件
    	 * @param bfile
    	 * @param filePath
    	 * @param fileName
    	 */
    	public static void writeFile(byte[] bfile, String filePath,String fileName) {
    		BufferedOutputStream bos = null;
    		FileOutputStream fos = null;
    		File file = null;
    		try {
    			File dir = new File(filePath);
    			if(!dir.exists()&&dir.isDirectory()){//判断文件目录是否存在
    				dir.mkdirs();
    			}
    			file = new File(filePath+"\\"+fileName);
    			fos = new FileOutputStream(file);
    			bos = new BufferedOutputStream(fos);
    			bos.write(bfile);
    		} catch (Exception e) {
    			e.printStackTrace();
    		} finally {
    			if (bos != null) {
    				try {
    					bos.close();
    				} catch (IOException e1) {
    					e1.printStackTrace();
    				}
    			}
    			if (fos != null) {
    				try {
    					fos.close();
    				} catch (IOException e1) {
    					e1.printStackTrace();
    				}
    			}
    		}
    	}
    
    	/**
    	 * MultipartFile转化File
    	 * @param mFile
    	 * @return
    	 */
    	public static File mutiToFile(MultipartFile mFile) {
    		File file = new File(mFile.getOriginalFilename());
    		try {
    			org.apache.commons.io.FileUtils.copyInputStreamToFile(mFile.getInputStream(), file);
    			return file;
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * File转化MultipartFile
    	 * @param file
    	 * @return MultipartFile
    	 */
    	public static MultipartFile filtToMuti(File file) {
    		FileInputStream input;
    		try {
    			input = new FileInputStream(file);
    			MultipartFile multipartFile;
    			multipartFile = new MockMultipartFile(file.getName(), file.getName(), "text/plain", IOUtils.toByteArray(input));
    			return multipartFile;
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * byte转化MultipartFile
    	 * @param bytes
    	 * @return MultipartFile
    	 */
    	public static MultipartFile byteToMuti(byte[] bytes) {
    		InputStream  input;
    		try {
    			byte[] fileByte = new byte[bytes.length];
    			input = new ByteArrayInputStream(fileByte);
    			MultipartFile multipartFile;
    			multipartFile = new MockMultipartFile(ContentType.APPLICATION_OCTET_STREAM.toString(), input);
    			return multipartFile;
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    	/**
    	 * 获取文件后缀
    	 * @param filename
    	 * @return
    	 */
    	public static String getSufix(String filename) {
    		if ((filename != null) && (filename.length() > 0)) {
    			int dot = filename.lastIndexOf('.');
    			if ((dot >-1) && (dot < (filename.length() - 1))) {
    				return filename.substring(dot + 1);
    			}
    		}
    		return "";
    	}
    }

    2. 需要配置引入的包

    <!-- 图片压缩 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-mock</artifactId>
        <version>2.0.8</version>
    </dependency>
    <dependency>
        <groupId>net.coobird</groupId>
        <artifactId>thumbnailator</artifactId>
        <version>0.4.8</version>
    </dependency>
    展开全文
  • 图片压缩缩放处理工具,支持自定义缩放功能。可以批量操作
  • 最近在做公司投标项目,要编辑大量的图片,需要压缩,有些还规定了大小,就想找个工具用用。 结果找到的基本都收费,免费的功能达不到要求。身为程序员肯定不能吭呲吭呲的手动搞啊,果断自己写了一个。 基本...

    最近在做公司投标项目,要编辑大量的图片,需要压缩,有些还规定了大小,就想找个工具用用。

    结果找到的基本都收费,免费的功能达不到要求。身为程序员肯定不能吭呲吭呲的手动搞啊,果断自己写了一个。

     


    基本功能满足:

    首先肯定要能批量处理啊。

    然后必须要可以自定义路径啊。

    支持覆盖原图或者在末尾添加字符生成新文件。

    支持自定义格式(目前只支持png和jpg)。

    支持设置图片质量(1-100)。

    支持设置图片大小(规定图片最大多少kb),这个功能只能做到大概没有那么精确。

    需要的朋友自行下载。IME批量图片处理工具

     

     

     

    展开全文
  • 工具可以进行图片压缩,图片缩放,可单独或批量处理,可以指定压缩的质量,比例,缩放程度,单页面操作简单
  • 免费的图片批量等比缩小软件,压缩工具压缩质量高。支持等比缩小和转换成1:1两种格式。支持文件夹一键压缩
  • 用python写的一个图片批量处理工具,对于有大量图片需要修改像素大小和图片占用空间压缩,还是比较实用的。 功能介绍: 1、将本工具放入图片同一级目录,直接运行就可以自动的批量处理了,同时会自动的覆盖原有...
  • Compress破解版是知您网搜集到的Mac os系统上一款可以轻松一步就完成图片压缩的轻便的Mac应用程序,而压缩后质量也可以保证。 通过调整压缩比,你会发现相比于原始和压缩图像的大小的差异。 您会对这个强大的压缩...
  • Riot图片压缩工具

    2012-07-03 19:14:06
    在网站中上传图片总感觉很大不利于网页加载,用Riot可以把图片处理得很小而又保持清晰,一个实用的图片压缩处理工具
  • 图片压缩工具

    2018-11-20 15:35:30
    图片压缩软件是一款绿色小巧的压缩图片文件占用空间大小,缩放图片尺寸的实用图片压缩工具。图片压缩缩放处理工具的界面设计使操作更简单,不用学习,直接使用,本图片压缩器可以任意复制,安装。支持批量压缩
  • 用python写的一个图片批量处理工具,对于有大量图片需要修改像素大小和图片占用空间压缩,还是比较实用的。 功能介绍: 1、将本工具放入图片同一级目录,直接运行就可以自动的批量处理了,同时会自动的覆盖原有图片...
  • 图片处理工具类,能缩放图片,给图片打水印等。
  • java 图片压缩 iphone拍照上传旋转问题处理,压缩工具类 首先导入jar 包,通过imgxz获取图片是否旋转属性,在调用旋转方法,旋转过来,然后在进行压缩
  • JPG图片压缩工具

    2019-03-07 23:15:16
    好用的JPG图片压缩工具,对JPG图片压缩有比较好的处理效果。
  • import org.apache.commons.lang.StringUtils; import sun.misc.BASE64Encoder; import javax.imageio.ImageIO; import java.awt.*; import java.awt.image.BufferedImage;...import java.io.ByteArrayOutputStream;...
    import org.apache.commons.lang.StringUtils;
    import sun.misc.BASE64Encoder;
     
    import javax.imageio.ImageIO;
    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.IOException;
    import java.net.MalformedURLException;
    import java.net.URL;
     
    /**
     * 图片处理工具类
     */
    public class ImageUtil {
     
        /**
         * 缩放后大小,默认90D
         */
        private static double base = 90D;
     
        public static void main(String[] args) throws IOException {
    /*        String path = "C:\\Users\\12\\Pictures\\不约.jpg";
            String newPath = "D:\\a.jpg";
            ImageUtil.zoomImageScale(new File(path), newPath);*/
     
            //String path = "E:\\3200_2000.jpg"; //宽比较长按照宽压缩
            //String newPath = "E:\\test1.jpg";
     
            String path = "E:\\1080_1920.jpg"; //高比较长按照高压缩
            String newPath = "E:\\test2.jpg";
     
            ImageUtil.zoomImageScale(new File(path), newPath, 386, 254);
     
        }
     
        /**
         * 压缩图片到默认大小
         *
         * @param imageFile
         * @param newPath
         * @throws IOException
         */
        public static void zoomImageScale(File imageFile, String newPath) throws IOException {
            if (!imageFile.canRead()) {
                return;
            }
            BufferedImage bufferedImage = ImageIO.read(imageFile);
            if (null == bufferedImage) {
                return;
            }
     
            int originalWidth = bufferedImage.getWidth();
            int originalHeight = bufferedImage.getHeight();
            int baseLength = Math.max(originalWidth, originalHeight);
            double scale = (double) baseLength / base; // 缩放的比例
     
            int newWidth = originalWidth == baseLength ? (int) base : (int) (originalWidth / scale);
            int newHeight = originalHeight == baseLength ? (int) base : (int) (originalHeight / scale);
     
            zoomImageUtils(imageFile, newPath, bufferedImage, newWidth, newHeight);
        }
     
        /**
         * 压缩图片到指定宽高度
         *
         * @param imageFile
         * @param newPath
         * @param width
         * @param height
         * @throws IOException
         */
        public static void zoomImageScale(File imageFile, String newPath, double width, double height) throws IOException {
            if (!imageFile.canRead()) {
                return;
            }
            BufferedImage bufferedImage = ImageIO.read(imageFile);
            if (null == bufferedImage) {
                return;
            }
     
            int originalWidth = bufferedImage.getWidth();
            int originalHeight = bufferedImage.getHeight();
            int baseLength = Math.max(originalWidth, originalHeight);
            double scale = (double) baseLength / width; // 缩放的比例
     
            int newWidth = originalWidth == baseLength ? (int) width : (int) (originalWidth / scale);
            int newHeight = originalHeight == baseLength ? (int) height : (int) (originalHeight / scale);
     
            if (newWidth == 0) {
                newWidth = 1;
            }
            if (newHeight == 0) {
                newHeight = 1;
            }
     
            zoomImageUtils(imageFile, newPath, bufferedImage, newWidth, newHeight);
        }
     
     
        private static void zoomImageUtils(File imageFile, String newPath, BufferedImage bufferedImage, int width,
                                           int height) throws IOException {
     
            String suffix = StringUtils.substringAfterLast(imageFile.getName(), ".");
     
            // 处理 png 背景变黑的问题
            if (suffix != null
                    && (suffix.trim().toLowerCase().endsWith("png") || suffix.trim().toLowerCase().endsWith("gif"))) {
                BufferedImage to = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
                Graphics2D g2d = to.createGraphics();
                to = g2d.getDeviceConfiguration().createCompatibleImage(width, height, Transparency.TRANSLUCENT);
                g2d.dispose();
     
                g2d = to.createGraphics();
                Image from = bufferedImage.getScaledInstance(width, height, Image.SCALE_AREA_AVERAGING);
                g2d.drawImage(from, 0, 0, null);
                g2d.dispose();
     
                ImageIO.write(to, suffix, new File(newPath));
            } else {
                // 高质量压缩,其实对清晰度而言没有太多的帮助
                // BufferedImage tag = new BufferedImage(width, height,
                // BufferedImage.TYPE_INT_RGB);
                // tag.getGraphics().drawImage(bufferedImage, 0, 0, width, height,
                // null);
                //
                // FileOutputStream out = new FileOutputStream(newPath); // 将图片写入
                // newPath
                // JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
                // JPEGEncodeParam jep = JPEGCodec.getDefaultJPEGEncodeParam(tag);
                // jep.setQuality(1f, true); //压缩质量, 1 是最高值
                // encoder.encode(tag, jep);
                // out.close();
     
                BufferedImage newImage = new BufferedImage(width, height, bufferedImage.getType());
                Graphics g = newImage.getGraphics();
                g.drawImage(bufferedImage, 0, 0, width, height, null);
                g.dispose();
                ImageIO.write(newImage, suffix, new File(newPath));
            }
        }
     
        /**
         * @Description : 将网络图片文件转化为字节数组字符串,并对其进行Base64编码处理
         * @param url 图片的url路径,如http://.....xx.jpg
         * @Date : 2018/7/9 15:47
         * @Author : Licf
         * @Modified By : Licf
         */
        public static String encodeImgageToBase64(String url) {
            URL imageUrl = null;
            try {
                imageUrl = new URL(url);
            } catch (MalformedURLException e) {
                e.printStackTrace();
            }
     
            //判断文件格式
            int index = url.lastIndexOf(".");
            String formatName = url.substring(index+1, url.length());
            if("jpg".equalsIgnoreCase(formatName)) {
                formatName = "jpg";
            } else if ("png".equalsIgnoreCase(formatName)) {
                formatName = "png";
            } else if ("JPEG".equalsIgnoreCase(formatName)) {
                formatName = "JPEG";
            } else {
                return null;
            }
     
            ByteArrayOutputStream outputStream = null;
            try {
                BufferedImage bufferedImage = ImageIO.read(imageUrl);
                outputStream = new ByteArrayOutputStream();
                ImageIO.write(bufferedImage, formatName, outputStream);
            } catch (MalformedURLException e1) {
                e1.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            // 对字节数组Base64编码
            BASE64Encoder encoder = new BASE64Encoder();
            return encoder.encode(outputStream.toByteArray());// 返回Base64编码过的字节数组字符串
        }
    }

     

    展开全文
  • 图片压缩与大小处理工具,可以能够压缩图片的大小,同时也可以改变图片大小,减少占用空间,尽管一些编辑器都有这样的功能,但是不如此类小软件方便。
  • pngquant图片压缩工具

    2017-12-27 12:03:58
    利用GitHub的开源pngquant项目,批量处理图片压缩工具,内置批量处理脚本,forWindows
  • 图片压缩制作工具

    2015-08-29 08:45:17
    对于图片按指定大小,指定像素进行压缩处理 ,很好用的软件,
  • Android图片压缩工具

    2021-04-05 14:52:29
    作者Curzibn,源码Luban,Luban(鲁班)——Android图片压缩工具,仿微信朋友圈压缩策略 项目描述 目前做app开发总绕不开图片这个元素。但是随着手机拍照分辨率的提升,图片的压缩成为一个很重要的问题。单纯对图片...
  • 主要功能:图片压缩,缩小图片尺寸,图片旋转,图片加文字或图片水印,支持批量处理。 图片经过处理后,减少对空间的占用,图片就能在网页上更快的显示。 这是一款绿色软件,下载后解压缩就能使用,无需安装。
  • 图片过大需要对图片进行大小的处理,不然在上传的时候就会有一系列的麻烦来找你,你需要知道的是有些平台对图片有限制,经过一系列的操作之后,最后告诉你图片太大,上传不了,你是不是会疯掉呢,我们在上传之前进行...
  • 中作中由于需要对图片进行压缩和裁剪,因此参考网上的各种方法写了以下工具类 [code="java"] package com.qxgf.xyz0.utils; import java.awt.Color; import java.awt.Graphics; import java.awt....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,438
精华内容 575
关键字:

图片压缩处理工具