Java中图片处理工具类，含等比缩放、图片裁剪

上传图片，对图片进行等比例缩放，及局部裁剪的工具类

 import java.awt.Container;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
 import java.awt.Image;
 import java.awt.MediaTracker;
 import java.awt.RenderingHints;
 import java.awt.Toolkit;
 import java.awt.image.BufferedImage;
 import java.awt.image.CropImageFilter;
 import java.awt.image.FilteredImageSource;
 import java.awt.image.ImageFilter;
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.UUID;

 import javax.imageio.ImageIO;

 import com.sun.image.codec.jpeg.JPEGCodec;
 import com.sun.image.codec.jpeg.JPEGEncodeParam;
 import com.sun.image.codec.jpeg.JPEGImageEncoder;

 public class FileUploadUtils {

     /**
      * 裁剪图片
      *
      * @param input
      * @param basepath
      * @param uid
      * @param x
      * @param y
      * @param width
      * @param height
      * @return 绝对路径
      * @throws IOException
      */
     public static String cutImg(String input, String basepath, int x, int y,
             int width, int height) throws IOException {
         String path2 = basepath + "/" + ConstantUtils.USERFACETEMPPATH;
         String postfix = getPostfix(input);
         String dst = path2 + "/" + UUID.randomUUID().toString() + "." + postfix;

         createDir(path2);
         imgCut(basepath + input, dst, postfix, x, y, width, height);

         return dst;
     }

     /**
      * 裁剪图片
      *
      * @param input
      * @param src
      * @param x
      * @param y
      * @param width
      * @param height
      * @throws IOException
      */
     public static void imgCut(String input, String dst, String type, int x,
             int y, int width, int height) throws IOException {
         BufferedImage fromimg = ImageIO.read(new File(input));
         ImageFilter cropFilter = new CropImageFilter(x, y, width, height);
         Image img = Toolkit.getDefaultToolkit().createImage(
                 new FilteredImageSource(fromimg.getSource(), cropFilter));
         BufferedImage tag = new BufferedImage(width, height,
                 BufferedImage.TYPE_INT_RGB);

         Graphics g = tag.getGraphics();
         g.drawImage(img, 0, 0, null); // 绘制小图
         g.dispose();
         // 输出为文件
         // dir = "d:\\temp\\cut_image_" + i + "_" + j + ".jpg";
         File f = new File(dst);
         ImageIO.write(tag, type, f);

     }

     /**
      * 上传头像文件
      *
      * @param src
      * @param basepath
      * @param filename
      * @return
      * @throws Exception
      */
     public static String uploadImg(File src, String basepath, String filename)
             throws Exception {
         String daypath = DateTools.getYear() + "" + DateTools.getMonth() + ""
                 + DateTools.getMonthWeek();

         String temppath = ConstantUtils.BASEUPLOADPATH + "/"
                 + ConstantUtils.ORIGINALIMGPATH + "/" + daypath;
         String thumbnailpath = ConstantUtils.BASEUPLOADPATH + "/"
                 + ConstantUtils.THUMBNAILIMGPATH + "/" + daypath;

         String postfix = getPostfix(filename);
         String uuid = UUID.randomUUID().toString();
         String dsttempname = uuid + "." + postfix;

         createDir(basepath + "/" + temppath);
         createDir(basepath + "/" + thumbnailpath);

         String dstallpath = basepath + "/" + temppath + "/" + dsttempname;
         String dstthumbnailpath = basepath + "/" + thumbnailpath + "/"
                 + dsttempname;

         copy(src, new File(dstallpath));

         // 对上传的文件进行 等比例 裁剪。 按照前段要展现的 height width
         Thumbnail(dstallpath, dstthumbnailpath, 350, 300, 100);

         // 返回裁剪后的路径

         return thumbnailpath + "/" + dsttempname;
     }

     /**
      * 上传文件
      *
      * @param src
      * @param dst
      * @throws Exception
      */
     public static void copy(File src, File dst) throws Exception {
         try {
             InputStream in = null;
             OutputStream out = null;
             try {
                 in = new BufferedInputStream(new FileInputStream(src),
                         ConstantUtils.BUFFER_SIZE);
                 out = new BufferedOutputStream(new FileOutputStream(dst),
                         ConstantUtils.BUFFER_SIZE);
                 byte[] buffer = new byte[ConstantUtils.BUFFER_SIZE];
                 while (in.read(buffer) > 0) {
                     out.write(buffer);
                 }
             } finally {
                 if (null != in) {
                     in.close();
                 }
                 if (null != out) {
                     out.close();
                 }
             }
         } catch (Exception e) {
             e.printStackTrace();
             throw e;
         }
     }

     /**
      * 得到文件后缀 jpg
      *
      * @param fileName
      * @return
      */
     public static String getPostfix(String fileName) {
         if (fileName.equals(""))
             return "";
         int pos = fileName.lastIndexOf(".");
         if (pos < 0) {
             return fileName.substring(fileName.length() - 3).toLowerCase();
         } else {
             return fileName.substring(pos + 1).toLowerCase();
         }
     }

     /**
      * 创建目录
      *
      * @param filePath
      */
     public static void createDir(String filePath) {
         File myFile = new File(filePath);
         if (!myFile.exists()) {
             if (!myFile.mkdirs())
                 System.out.println("创建目录 fail");
             else
                 System.out.println("创建目录 success");
         }
         myFile = null;
     }

     /**
      * 等比例缩放图片
      *
      * @param infile
      * @param outfile
      * @param width
      * @param height
      * @param quality
      * @throws IOException
      * @throws InterruptedException
      */
     public static void Thumbnail(String infile, String outfile, int width,
             int height, int quality) throws IOException, InterruptedException {
         // save thumbnail image to OUTFILE
         // System.out.println("infile:" + infile);
         BufferedImage thumbImage = null;
         BufferedOutputStream out = null;
         Image image = null;
         image = Toolkit.getDefaultToolkit().createImage(infile);
         MediaTracker mediaTracker = new MediaTracker(new Container());
         mediaTracker.addImage(image, 0);
         mediaTracker.waitForID(0);
         int thumbWidth = width;
         int thumbHeight = height;
         double thumbRatio = (double) thumbWidth / (double) thumbHeight;
         int imageWidth = image.getWidth(null);
         int imageHeight = image.getHeight(null);
         double imageRatio = (double) imageWidth / (double) imageHeight;
         if (thumbRatio < imageRatio) {
             thumbHeight = (int) (thumbWidth / imageRatio);
         } else {
             thumbWidth = (int) (thumbHeight * imageRatio);
         }
         thumbImage = new BufferedImage(thumbWidth, thumbHeight,
                 BufferedImage.TYPE_INT_RGB);
         Graphics2D graphics2D = thumbImage.createGraphics();
         graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                 RenderingHints.VALUE_INTERPOLATION_BILINEAR);
         graphics2D.drawImage(image, 0, 0, thumbWidth, thumbHeight, null);
         out = new BufferedOutputStream(new FileOutputStream(outfile));
         JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
         JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(thumbImage);
         quality = Math.max(0, Math.min(quality, 100));
         param.setQuality((float) quality / 100.0f, false);
         encoder.setJPEGEncodeParam(param);
         encoder.encode(thumbImage);
         out.close();
         thumbImage = null;
         out = null;
         image = null;
     }
 }

java图片裁剪处理工具类代码

剪切前：  

原文：java图片裁剪处理工具类代码

源代码下载地址：http://www.zuidaima.com/share/1550463351786496.htm

剪切后： 

 package com.zuidaima.zhangjun.image;

 import java.awt.Rectangle;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.util.Iterator;
 import javax.imageio.ImageIO;
 import javax.imageio.ImageReadParam;
 import javax.imageio.ImageReader;
 import javax.imageio.stream.ImageInputStream;
 /**
 *@author www.zuidaima.com
 **/
 public class OperateImage {
     // ===源图片路径名称如：c:\1.jpg
     private String srcpath;
     // ===剪切图片存放路径名称。如：c:\2.jpg
     private String subpath;
     // ===剪切点x坐标
     private int x;
     private int y;
     // ===剪切点宽度
     private int width;
     private int height;

     public OperateImage() {
     }

     public OperateImage(int x, int y, int width, int height) {
         this.x = x;
         this.y = y;
         this.width = width;
         this.height = height;
     }

     /**
      * 对图片裁剪，并把裁剪完的新图片保存 。
      */
     public void cut() throws IOException {
         FileInputStream is = null;
         ImageInputStream iis = null;
         try {
             // 读取图片文件
             is = new FileInputStream(srcpath);
             /**
              * 返回包含所有当前已注册 ImageReader 的 Iterator，这些 ImageReader
              * 声称能够解码指定格式。 参数：formatName - 包含非正式格式名称 .
              * (例如 "jpeg" 或 "tiff")等 。
              */
             Iterator<ImageReader> it = ImageIO
                     .getImageReadersByFormatName("jpg");
             ImageReader reader = it.next();
             // 获取图片流
             iis = ImageIO.createImageInputStream(is);
             /**
              * iis:读取源。true:只向前搜索
              * 将它标记为 ‘只向前搜索’。
              * 此设置意味着包含在输入源中的图像将只按顺序读取，可能允许 reader
              * 避免缓存包含与以前已经读取的图像关联的数据的那些输入部分。
              */
             reader.setInput(iis, true);
             /**
              * <p>
              * 描述如何对流进行解码的类
              * <p>
              * 用于指定如何在输入时从 Java Image I/O
              * 框架的上下文中的流转换一幅图像或一组图像。用于特定图像格式的插件
              * 将从其 ImageReader 实现的 getDefaultReadParam 方法中返回
              * ImageReadParam 的实例。
              */
             ImageReadParam param = reader.getDefaultReadParam();
             /**
              * 图片裁剪区域。Rectangle 指定了坐标空间中的一个区域，通过 Rectangle 对象
              * 的左上顶点的坐标(x，y)、宽度和高度可以定义这个区域。
              */
             Rectangle rect = new Rectangle(x, y, width, height);
             // 提供一个 BufferedImage，将其用作解码像素数据的目标。
             param.setSourceRegion(rect);
             /**
              * 使用所提供的 ImageReadParam 读取通过索引 imageIndex 指定的对象，并将
              * 它作为一个完整的 BufferedImage 返回。
              */
             BufferedImage bi = reader.read(0, param);
             // 保存新图片
             ImageIO.write(bi, "jpg", new File(subpath));
         } finally {
             if (is != null)
                 is.close();
             if (iis != null)
                 iis.close();
         }
     }

     public int getHeight() {
         return height;
     }

     public void setHeight(int height) {
         this.height = height;
     }

     public String getSrcpath() {
         return srcpath;
     }

     public void setSrcpath(String srcpath) {
         this.srcpath = srcpath;
     }

     public String getSubpath() {
         return subpath;
     }

     public void setSubpath(String subpath) {
         this.subpath = subpath;
     }

     public int getWidth() {
         return width;
     }

     public void setWidth(int width) {
         this.width = width;
     }

     public int getX() {
         return x;
     }

     public void setX(int x) {
         this.x = x;
     }

     public int getY() {
         return y;
     }

     public void setY(int y) {
         this.y = y;
     }

     public static void main(String[] args) throws Exception {
         String name = "D:\\zuidaima\\image.jpg";
         OperateImage o = new OperateImage(60, 5, 80, 100);
         o.setSrcpath(name);
         o.setSubpath("F:\\zuidaima\\3.jpg");
         o.cut();
     }
 }

 

java图片文件处理工具类【包括图片缩放，剪切等功能】

 package com.taocz.youngth.util;

 import java.awt.Graphics;
 import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsDevice;
 import java.awt.GraphicsEnvironment;
 import java.awt.HeadlessException;
 import java.awt.Image;
 import java.awt.Rectangle;
 import java.awt.Transparency;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.Random;

 import javax.imageio.ImageIO;
 import javax.imageio.ImageReadParam;
 import javax.imageio.ImageReader;
 import javax.imageio.stream.ImageInputStream;
 import javax.swing.ImageIcon;

 import com.sun.image.codec.jpeg.JPEGCodec;
 import com.sun.image.codec.jpeg.JPEGImageEncoder;

 /**
  * @作者 王建明
  * @创建日期 2012-6-16
  * @创建时间 下午02:35:31
  * @版本号 V 1.0
  */
 public class IconCompressUtil {
     public String path = "";

     public IconCompressUtil(String path) {
         this.path = path;
     }

     public void change(int size) {
         compressImg(new File(path), size, null);
     }

     /**
      * @param oldfile
      * @param size
      * @param newfile
      * @return
      * @作者 王建明
      * @创建日期 2012-6-16
      * @创建时间 下午03:30:48
      * @描述 —— 将oldfile的图片文件等比例压缩为size的newfile文件
      */
     public static File compressImg(File oldfile, int size, File newfile) {
         if(!newfile.exists())
             try {
                 newfile.createNewFile();
             } catch (IOException e1) {
                 // TODO Auto-generated catch block
                 //e1.printStackTrace();
                 System.out.println("无法创建文件！！！");
                 return null;
             }
         BufferedImage bi;
         try {
             System.out.println("正在压缩:" + oldfile.getName());
             bi = ImageIO.read(new FileInputStream(oldfile));
             int width = bi.getWidth();
             int height = bi.getHeight();
             if (width > size || height > size) {
                 Image image;
                 if (width > height) {
                     height = (int) (bi.getHeight() / (bi.getWidth() * 1d) * size);
                     image = bi.getScaledInstance(size, height,
                             Image.SCALE_DEFAULT);
                 } else {
                     width = (int) (bi.getWidth() / (bi.getHeight() * 1d) * size);
                     image = bi.getScaledInstance(width, size,
                             Image.SCALE_DEFAULT);
                 }
                 ImageIO.write(toBufferedImage(image), "png",
                         new FileOutputStream(newfile));
                 System.out.println("压缩完成:" + newfile.getName());
                 return newfile;
             } else {
                 System.out.println("无须压缩:" + oldfile.getName());
                 return oldfile;
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         return null;
     }

     public static BufferedImage toBufferedImage(Image image) {
         if (image instanceof BufferedImage) {
             return (BufferedImage) image;
         }
         image = new ImageIcon(image).getImage();
         BufferedImage bimage = null;
         GraphicsEnvironment ge = GraphicsEnvironment
                 .getLocalGraphicsEnvironment();
         try {
             int transparency = Transparency.TRANSLUCENT;
             GraphicsDevice gs = ge.getDefaultScreenDevice();
             GraphicsConfiguration gc = gs.getDefaultConfiguration();
             bimage = gc.createCompatibleImage(image.getWidth(null), image
                     .getHeight(null), transparency);
         } catch (HeadlessException e) {
         }
         if (bimage == null) {
             int type = BufferedImage.TYPE_INT_RGB;
             bimage = new BufferedImage(image.getWidth(null), image
                     .getHeight(null), type);
         }
         Graphics g = bimage.createGraphics();
         g.drawImage(image, 0, 0, null);
         g.dispose();
         return bimage;
     }

     /**
      * @return
      * @作者 王建明
      * @创建日期 2012-8-2
      * @创建时间 下午02:00:41
      * @描述 —— 生成随机名字，不可能重复(用于文件的命名)
      */
     public static String getRandomName() {
         Random r = new Random();
         SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd_HHmmssSSS");
         StringBuffer sb = new StringBuffer();
         sb.append(r.nextInt(100));
         sb.append(r.nextInt(100));
         sb.append("_");
         sb.append(sdf.format(new Date()));
         sb.append("_");
         sb.append(r.nextInt(100));
         sb.append(r.nextInt(100));
         return sb.toString();
     }

     /**
      * @param inputFile源文件
      * @param outFile生成文件
      * @param width指定宽度
      * @param height指定高度
      * @param proportion是否等比例操作
      * @return
      * @作者 王建明
      * @创建日期 2012-8-2
      * @创建时间 下午02:02:38
      * @描述 —— 是否等比例缩放图片
      */
     public static boolean compressPic(String inputFile, String outFile,
             int width, int height, boolean proportion) {
         try {
             // 获得源文件
             File file = new File(inputFile);
             if (!file.exists()) {
                 return false;
             }
             Image img = ImageIO.read(file);
             // 判断图片格式是否正确
             if (img.getWidth(null) == -1) {
                 return false;
             } else {
                 int newWidth;
                 int newHeight;
                 // 判断是否是等比缩放
                 if (proportion == true) {
                     // 为等比缩放计算输出的图片宽度及高度
                     double rate1 = ((double) img.getWidth(null))
                             / (double) width + 0.1;
                     double rate2 = ((double) img.getHeight(null))
                             / (double) height + 0.1;
                     // 根据缩放比率大的进行缩放控制
                     double rate = rate1 > rate2 ? rate1 : rate2;
                     newWidth = (int) (((double) img.getWidth(null)) / rate);
                     newHeight = (int) (((double) img.getHeight(null)) / rate);
                 } else {
                     newWidth = width; // 输出的图片宽度
                     newHeight = height; // 输出的图片高度
                 }

                 // 如果图片小于目标图片的宽和高则不进行转换
                 /*
                  * if (img.getWidth(null) < width && img.getHeight(null) <
                  * height) { newWidth = img.getWidth(null); newHeight =
                  * img.getHeight(null); }
                  */
                 BufferedImage tag = new BufferedImage((int) newWidth,
                         (int) newHeight, BufferedImage.TYPE_INT_RGB);

                 // Image.SCALE_SMOOTH 的缩略算法 生成缩略图片的平滑度的,优先级比速度高 生成的图片质量比较好 但速度慢
                 tag.getGraphics().drawImage(
                         img.getScaledInstance(newWidth, newHeight,
                                 Image.SCALE_SMOOTH), 0, 0, null);
                 FileOutputStream out = new FileOutputStream(outFile);
                 // JPEGImageEncoder可适用于其他图片类型的转换
                 JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
                 encoder.encode(tag);
                 out.close();
             }
         } catch (IOException ex) {
             ex.printStackTrace();
         }
         return true;
     }

     /**
      * @param srcFile源文件
      * @param outFile输出文件
      * @param x坐标
      * @param y坐标
      * @param width宽度
      * @param height高度
      * @return
      * @作者 王建明
      * @创建日期 2012-8-2
      * @创建时间 下午02:05:03
      * @描述 —— 裁剪图片
      */
     public static boolean cutPic(String srcFile, String outFile, int x, int y,
             int width, int height) {
         FileInputStream is = null;
         ImageInputStream iis = null;
         try {
             // 如果源图片不存在
             if (!new File(srcFile).exists()) {
                 return false;
             }

             // 读取图片文件
             is = new FileInputStream(srcFile);

             // 获取文件格式
             String ext = srcFile.substring(srcFile.lastIndexOf(".") + 1);

             // ImageReader声称能够解码指定格式
             Iterator<ImageReader> it = ImageIO.getImageReadersByFormatName(ext);
             ImageReader reader = it.next();

             // 获取图片流
             iis = ImageIO.createImageInputStream(is);

             // 输入源中的图像将只按顺序读取
             reader.setInput(iis, true);

             // 描述如何对流进行解码
             ImageReadParam param = reader.getDefaultReadParam();

             // 图片裁剪区域
             Rectangle rect = new Rectangle(x, y, width, height);

             // 提供一个 BufferedImage，将其用作解码像素数据的目标
             param.setSourceRegion(rect);

             // 使用所提供的 ImageReadParam 读取通过索引 imageIndex 指定的对象
             BufferedImage bi = reader.read(0, param);

             // 保存新图片
             File tempOutFile = new File(outFile);
             if (!tempOutFile.exists()) {
                 tempOutFile.mkdirs();
             }
             ImageIO.write(bi, ext, new File(outFile));
             return true;
         } catch (Exception e) {
             e.printStackTrace();
             return false;
         } finally {
             try {
                 if (is != null) {
                     is.close();
                 }
                 if (iis != null) {
                     iis.close();
                 }
             } catch (IOException e) {
                 e.printStackTrace();
                 return false;
             }
         }
     }

     /**
      * @param doubleValue
      * @return
      * @作者 王建明
      * @创建日期 2012-8-6
      * @创建时间 下午05:24:15
      * @描述 —— 将浮点型数据保留整数位转换成int型
      */
     public static Integer getRoundIntFromDouble(Double doubleValue) {
         return Integer.parseInt(String.valueOf(Math.round(doubleValue)));
     }
 }