java 程序實現對圖片的壓縮生成縮略圖並可設定長寬、尺寸壓縮率、圖片質量

以前是在另外一位高手的上傳內容中學習到的，並將其代碼根據個人需求進行了修改，參考位置：http://jiangpin1987.javaeye.com/blog/749690

 

參考代碼：

import java.io.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.awt.*;
import com.sun.image.codec.jpeg.*;
import java.awt.image.BufferedImage;

public class Img_Middle {
	public void img_change(String url, String name) {
		Tosmallerpic(url, new File(url + name), "_middle", name, 188, 165,
				(float) 0.7);
		Tosmallerpic(url, new File(url + name), "_small", name, 45, 45,
				(float) 0.7);
		Tosmallerpic(url, new File(url + name), "_smaller", name, 116, 100,
				(float) 0.7);
	}

	/**
	 * * * @param f 圖片所在的文件夾路徑 * @param filelist 圖片路徑 *
	 * 
	 * @param ext
	 *            擴展名
	 * @param n
	 *            圖片名
	 * @param w
	 *            目標寬 *
	 * @param h
	 *            目標高 *
	 * @param per
	 *            百分比
	 */
	private static void Tosmallerpic(String f, File filelist, String ext,
			String n, int w, int h, float per) {
		Image src;
		try {
			src = javax.imageio.ImageIO.read(filelist);
			// 構造Image對象
			String img_midname = f + n.substring(0, n.indexOf(".")) + ext
					+ n.substring(n.indexOf("."));
			int old_w = src.getWidth(null); // 獲得源圖寬
			int old_h = src.getHeight(null);
			int new_w = 0;
			int new_h = 0; // 獲得源圖長
			double w2 = (old_w * 1.00) / (w * 1.00);
			double h2 = (old_h * 1.00) / (h * 1.00);
			// 圖片跟據長寬留白，成一個正方形圖。
			BufferedImage oldpic;
			if (old_w > old_h) {
				oldpic = new BufferedImage(old_w, old_w,
						BufferedImage.TYPE_INT_RGB);
			} else {
				if (old_w < old_h) {
					oldpic = new BufferedImage(old_h, old_h,
							BufferedImage.TYPE_INT_RGB);
				} else {
					oldpic = new BufferedImage(old_w, old_h,
							BufferedImage.TYPE_INT_RGB);
				}
			}
			Graphics2D g = oldpic.createGraphics();
			g.setColor(Color.white);
			if (old_w > old_h) {
				g.fillRect(0, 0, old_w, old_w);
				g.drawImage(src, 0, (old_w - old_h) / 2, old_w, old_h,
						Color.white, null);
			} else {
				if (old_w < old_h) {
					g.fillRect(0, 0, old_h, old_h);
					g.drawImage(src, (old_h - old_w) / 2, 0, old_w, old_h,
							Color.white, null);
				} else {

					// g.fillRect(0,0,old_h,old_h);
					g.drawImage(src.getScaledInstance(old_w, old_h,
							Image.SCALE_SMOOTH), 0, 0, null);
				}
			}
			g.dispose();
			src = oldpic;
			// 圖片調整爲方形結束
			if (old_w > w)
				new_w = (int) Math.round(old_w / w2);
			else
				new_w = old_w;
			if (old_h > h)
				new_h = (int) Math.round(old_h / h2);// 計算新圖長寬
			else
				new_h = old_h;
			BufferedImage tag = new BufferedImage(new_w, new_h,
					BufferedImage.TYPE_INT_RGB);
			// tag.getGraphics().drawImage(src,0,0,new_w,new_h,null);
			// 繪製縮小後的圖
			tag.getGraphics().drawImage(
					src.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,
					0, null);
			FileOutputStream newimage = new FileOutputStream(img_midname); // 輸出到文件流
			JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(newimage);
			JPEGEncodeParam jep = JPEGCodec.getDefaultJPEGEncodeParam(tag);
			/* 壓縮質量 */
			jep.setQuality(per, true);
			encoder.encode(tag, jep);
			// encoder.encode(tag);
			// 近JPEG編碼
			newimage.close();
		} catch (IOException ex) {
			Logger.getLogger(Img_Middle.class.getName()).log(Level.SEVERE,
					null, ex);
		}
	}
	
	public static void main(String args[]){      
		//String n="0e5465fc-025a-458d-8383-e9ced0c1e728.jpg";    
		String f="F://200903300012//pics//201006//";   
		File file=new File(f);        
		if(file.exists()){      
			File[] filelist=file.listFiles(); 
			for(int i=0;i<filelist.length;i++){        
				String n=filelist[i].getName(); 
				Tosmallerpic(f,filelist[i],"_middle",n,185,160,(float)0.7);  
				Tosmallerpic(f,filelist[i],"_small",n,45,45,(float)0.7);  
				Tosmallerpic(f,filelist[i],"_smaller",n,116,100,(float)0.7);  
			}      
		}  
	}
}

 

 

第一次修改後的代碼：

 

import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Calendar;
import java.util.Date;
import com.sun.image.codec.jpeg.ImageFormatException;
import com.sun.image.codec.jpeg.JPEGCodec;
import com.sun.image.codec.jpeg.JPEGEncodeParam;
import com.sun.image.codec.jpeg.JPEGImageEncoder;

/**
 * * @author WQ
 * 
 * @date 2011-01-14
 * @versions 1.0 圖片壓縮工具類 提供的方法中能夠設定生成的 縮略圖片的大小尺寸、壓縮尺寸的比例、圖片的質量等
 */
public class ImageUtil {

	/**
	 * * 圖片文件讀取
	 * 
	 * @param srcImgPath
	 * @return
	 */
	private static BufferedImage InputImage(String srcImgPath) {

		BufferedImage srcImage = null;
		try {
			// 構造BufferedImage對象
			File file = new File(srcImgPath);
			FileInputStream in = new FileInputStream(file);
			byte[] b = new byte[5];
			in.read(b);
			srcImage = javax.imageio.ImageIO.read(file);
		} catch (IOException e) {
			System.out.println("讀取圖片文件出錯！" + e.getMessage());
			e.printStackTrace();
		}
		return srcImage;
	}

	/**
	 * * 將圖片按照指定的圖片尺寸、源圖片質量壓縮(默認質量爲1)
	 * 
	 * @param srcImgPath
	 *            :源圖片路徑
	 * @param outImgPath
	 *            :輸出的壓縮圖片的路徑
	 * @param new_w
	 *            :壓縮後的圖片寬
	 * @param new_h
	 *            :壓縮後的圖片高
	 */
	public static void Tosmallerpic(String srcImgPath, String outImgPath,
			int new_w, int new_h) {
		Tosmallerpic(srcImgPath, outImgPath, new_w, new_h, 1F);
	}

	/**
	 * 將圖片按照指定的尺寸比例、源圖片質量壓縮(默認質量爲1)
	 * 
	 * @param srcImgPath
	 *            :源圖片路徑
	 * @param outImgPath
	 *            :輸出的壓縮圖片的路徑
	 * @param ratio
	 *            :壓縮後的圖片尺寸比例
	 * @param per
	 *            :百分比
	 */
	public static void Tosmallerpic(String srcImgPath, String outImgPath,
			float ratio) {
		Tosmallerpic(srcImgPath, outImgPath, ratio, 1F);
	}

	/**
	 * 將圖片按照指定長或者寬的最大值來壓縮圖片(默認質量爲1)
	 * 
	 * @param srcImgPath
	 *            :源圖片路徑
	 * @param outImgPath
	 *            :輸出的壓縮圖片的路徑
	 * @param maxLength
	 *            :長或者寬的最大值
	 * @param per
	 *            :圖片質量
	 */
	public static void Tosmallerpic(String srcImgPath, String outImgPath,
			int maxLength) {
		Tosmallerpic(srcImgPath, outImgPath, maxLength, 1F);
	}

	/**
	 * * 將圖片按照指定的圖片尺寸、圖片質量壓縮
	 * 
	 * @param srcImgPath
	 *            :源圖片路徑
	 * @param outImgPath
	 *            :輸出的壓縮圖片的路徑
	 * @param new_w
	 *            :壓縮後的圖片寬
	 * @param new_h
	 *            :壓縮後的圖片高
	 * @param per
	 *            :百分比
	 */
	public static void Tosmallerpic(String srcImgPath, String outImgPath,
			int new_w, int new_h, float per) {
		// 獲得圖片
		BufferedImage src = InputImage(srcImgPath);
		int old_w = src.getWidth();
		// 獲得源圖寬
		int old_h = src.getHeight();
		// 獲得源圖長
		// 根據原圖的大小生成空白畫布
		BufferedImage tempImg = new BufferedImage(old_w, old_h,
				BufferedImage.TYPE_INT_RGB);
		// 在新的畫布上生成原圖的縮略圖
		Graphics2D g = tempImg.createGraphics();
		g.setColor(Color.white);
		g.fillRect(0, 0, old_w, old_h);
		g.drawImage(src, 0, 0, old_w, old_h, Color.white, null);
		g.dispose();
		BufferedImage newImg = new BufferedImage(new_w, new_h,
				BufferedImage.TYPE_INT_RGB);
		newImg.getGraphics().drawImage(
				tempImg.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,
				0, null);
		// 調用方法輸出圖片文件
		OutImage(outImgPath, newImg, per);
	}

	/**
	 * * 將圖片按照指定的尺寸比例、圖片質量壓縮
	 * 
	 * @param srcImgPath
	 *            :源圖片路徑
	 * @param outImgPath
	 *            :輸出的壓縮圖片的路徑
	 * @param ratio
	 *            :壓縮後的圖片尺寸比例
	 * @param per
	 *            :百分比
	 */
	public static void Tosmallerpic(String srcImgPath, String outImgPath,
			float ratio, float per) {
		// 獲得圖片
		BufferedImage src = InputImage(srcImgPath);
		int old_w = src.getWidth();
		// 獲得源圖寬
		int old_h = src.getHeight();
		// 獲得源圖長
		int new_w = 0;
		// 新圖的寬
		int new_h = 0;
		// 新圖的長
		BufferedImage tempImg = new BufferedImage(old_w, old_h,
				BufferedImage.TYPE_INT_RGB);
		Graphics2D g = tempImg.createGraphics();
		g.setColor(Color.white);
		// 從原圖上取顏色繪製新圖g.fillRect(0, 0, old_w, old_h);
		g.drawImage(src, 0, 0, old_w, old_h, Color.white, null);
		g.dispose();
		// 根據圖片尺寸壓縮比獲得新圖的尺寸new_w = (int) Math.round(old_w * ratio);
		new_h = (int) Math.round(old_h * ratio);
		BufferedImage newImg = new BufferedImage(new_w, new_h,
				BufferedImage.TYPE_INT_RGB);
		newImg.getGraphics().drawImage(
				tempImg.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,
				0, null);
		// 調用方法輸出圖片文件OutImage(outImgPath, newImg, per);
	}

	/**
	 * * 指定長或者寬的最大值來壓縮圖片
	 * 
	 * @param srcImgPath
	 *            :源圖片路徑
	 * @param outImgPath
	 *            :輸出的壓縮圖片的路徑
	 * @param maxLength
	 *            :長或者寬的最大值
	 * @param per
	 *            :圖片質量
	 */
	public static void Tosmallerpic(String srcImgPath, String outImgPath,
			int maxLength, float per) {
		// 獲得圖片
		BufferedImage src = InputImage(srcImgPath);
		int old_w = src.getWidth();
		// 獲得源圖寬
		int old_h = src.getHeight();
		// 獲得源圖長
		int new_w = 0;
		// 新圖的寬
		int new_h = 0;
		// 新圖的長
		BufferedImage tempImg = new BufferedImage(old_w, old_h,
				BufferedImage.TYPE_INT_RGB);
		Graphics2D g = tempImg.createGraphics();
		g.setColor(Color.white);
		// 從原圖上取顏色繪製新圖
		g.fillRect(0, 0, old_w, old_h);
		g.drawImage(src, 0, 0, old_w, old_h, Color.white, null);
		g.dispose();
		// 根據圖片尺寸壓縮比獲得新圖的尺寸
		if (old_w > old_h) {
			// 圖片要縮放的比例
			new_w = maxLength;
			new_h = (int) Math.round(old_h * ((float) maxLength / old_w));
		} else {
			new_w = (int) Math.round(old_w * ((float) maxLength / old_h));
			new_h = maxLength;
		}
		BufferedImage newImg = new BufferedImage(new_w, new_h,
				BufferedImage.TYPE_INT_RGB);
		newImg.getGraphics().drawImage(
				tempImg.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,
				0, null);
		// 調用方法輸出圖片文件
		OutImage(outImgPath, newImg, per);
	}

	/**
	 * * 將圖片文件輸出到指定的路徑，並可設定壓縮質量
	 * 
	 * @param outImgPath
	 * @param newImg
	 * @param per
	 */
	private static void OutImage(String outImgPath, BufferedImage newImg,
			float per) {
		// 判斷輸出的文件夾路徑是否存在，不存在則建立
		File file = new File(outImgPath);
		if (!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}// 輸出到文件流
		try {
			FileOutputStream newimage = new FileOutputStream(outImgPath);
			JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(newimage);
			JPEGEncodeParam jep = JPEGCodec.getDefaultJPEGEncodeParam(newImg);
			// 壓縮質量
			jep.setQuality(per, true);
			encoder.encode(newImg, jep);
			newimage.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch blocke.printStackTrace();
		} catch (ImageFormatException e) {
			// TODO Auto-generated catch blocke.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch blocke.printStackTrace();
		}
	}

	public static void main(String args[]) {
		String f = "c:/img/";
		File file = new File(f);
		if (file.exists()) {
			File[] filelist = file.listFiles();
			for (int i = 0; i < filelist.length; i++) {
				File fi = filelist[i];
				System.out.println(fi.length());
				String n = filelist[i].getName();
				// Tosmallerpic(f, filelist[i], "_ratio_small", n,
				// 0.303,(float)0.7);
				// Tosmallerpic(f, filelist[i], "_ratio_smaller", n,
				// 0.083,(float)0.7);
			}
		}
		String srcImg = "c:/img/car_2.jpg";
		String tarDir = "c:/img/newImg/";
		long startTime = new Date().getTime();
		Tosmallerpic(srcImg, tarDir + "car_1_maxLength_1.jpg", 400);
		Tosmallerpic(srcImg, tarDir + "car_1_maxLength_2.jpg", 0.5F);
		Tosmallerpic(srcImg, tarDir + "car_1_maxLength_3.jpg", 400, 500);
		Tosmallerpic(srcImg, tarDir + "car_1_maxLength_11.jpg", 400, 0.7F);
		Tosmallerpic(srcImg, tarDir + "car_1_maxLength_22.jpg", 0.5F, 0.8F);
		Tosmallerpic(srcImg, tarDir + "car_1_maxLength_33.jpg", 400, 500, 0.8F);
		System.out.println(new Date().getTime() - startTime);
	}
}

 

 

第二次修改，只是對長寬尺寸壓縮，按原圖片質量

import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import javax.imageio.ImageIO;

/**
 * * @author WQ * @date 2011-01-14 * @versions 1.0 圖片壓縮工具類 提供的方法中能夠設定生成的
 * 縮略圖片的大小尺寸等
 */
public class ImageUtil {
	/** * 圖片文件讀取 * * @param srcImgPath * @return */
	private static BufferedImage InputImage(String srcImgPath) {
		BufferedImage srcImage = null;
		try {
			FileInputStream in = new FileInputStream(srcImgPath);
			srcImage = javax.imageio.ImageIO.read(in);
		} catch (IOException e) {
			System.out.println("讀取圖片文件出錯！" + e.getMessage());
			e.printStackTrace();
		}
		return srcImage;
	}

	/**
	 * * 將圖片按照指定的圖片尺寸壓縮 * * @param srcImgPath :源圖片路徑 * @param outImgPath *
	 * :輸出的壓縮圖片的路徑 * @param new_w * :壓縮後的圖片寬 * @param new_h * :壓縮後的圖片高
	 */
	public static void compressImage(String srcImgPath, String outImgPath,
			int new_w, int new_h) {
		BufferedImage src = InputImage(srcImgPath);
		disposeImage(src, outImgPath, new_w, new_h);
	}

	/**
	 * * 指定長或者寬的最大值來壓縮圖片 * * @param srcImgPath * :源圖片路徑 * @param outImgPath *
	 * :輸出的壓縮圖片的路徑 * @param maxLength * :長或者寬的最大值
	 */
	public static void compressImage(String srcImgPath, String outImgPath,
			int maxLength) {
		// 獲得圖片
		BufferedImage src = InputImage(srcImgPath);
		if (null != src) {
			int old_w = src.getWidth();
			// 獲得源圖寬
			int old_h = src.getHeight();
			// 獲得源圖長
			int new_w = 0;
			// 新圖的寬
			int new_h = 0;
			// 新圖的長
			// 根據圖片尺寸壓縮比獲得新圖的尺寸
			if (old_w > old_h) {
				// 圖片要縮放的比例
				new_w = maxLength;
				new_h = (int) Math.round(old_h * ((float) maxLength / old_w));
			} else {
				new_w = (int) Math.round(old_w * ((float) maxLength / old_h));
				new_h = maxLength;
			}
			disposeImage(src, outImgPath, new_w, new_h);
		}
	}

	/** * 處理圖片 * * @param src * @param outImgPath * @param new_w * @param new_h */
	private synchronized static void disposeImage(BufferedImage src,
			String outImgPath, int new_w, int new_h) {
		// 獲得圖片
		int old_w = src.getWidth();
		// 獲得源圖寬
		int old_h = src.getHeight();
		// 獲得源圖長
		BufferedImage newImg = null;
		// 判斷輸入圖片的類型
		switch (src.getType()) {
		case 13:
			// png,gifnewImg = new BufferedImage(new_w, new_h,
			// BufferedImage.TYPE_4BYTE_ABGR);
			break;
		default:
			newImg = new BufferedImage(new_w, new_h, BufferedImage.TYPE_INT_RGB);
			break;
		}
		Graphics2D g = newImg.createGraphics();
		// 從原圖上取顏色繪製新圖
		g.drawImage(src, 0, 0, old_w, old_h, null);
		g.dispose();
		// 根據圖片尺寸壓縮比獲得新圖的尺寸
		newImg.getGraphics().drawImage(
				src.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0, 0,
				null);
		// 調用方法輸出圖片文件
		OutImage(outImgPath, newImg);
	}

	/**
	 * * 將圖片文件輸出到指定的路徑，並可設定壓縮質量 * * @param outImgPath * @param newImg * @param
	 * per
	 */
	private static void OutImage(String outImgPath, BufferedImage newImg) {
		// 判斷輸出的文件夾路徑是否存在，不存在則建立
		File file = new File(outImgPath);
		if (!file.getParentFile().exists()) {
			file.getParentFile().mkdirs();
		}// 輸出到文件流
		try {
			ImageIO.write(newImg, outImgPath.substring(outImgPath
					.lastIndexOf(".") + 1), new File(outImgPath));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
 

 

 另見參考：http://www.javaeye.com/topic/266585