利用ImageIO压缩图片

http://java-mzd.iteye.com/blog/730504

http://blog.csdn.net/10km/article/details/52119508

参考上面文章，测试了下 很好用！

500kb左右的图片，压缩4次，1秒内完毕。

import java.awt.AWTException;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Iterator;

import javax.imageio.IIOImage;
import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.ImageWriteParam;
import javax.imageio.ImageWriter;
import javax.imageio.stream.ImageInputStream;
import javax.imageio.stream.MemoryCacheImageInputStream;

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

public class ImageTest {
	/**
	 * @param args
	 * @throws AWTException
	 * @throws IOException 
	 * @throws FileNotFoundException 
	 */
	public void getImageSize() throws AWTException, FileNotFoundException, IOException {
		java.awt.Robot rb = new java.awt.Robot();
		Dimension d = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
		Rectangle rt = new Rectangle(0, 0, (int) d.getWidth(), (int) d
				.getHeight());
		BufferedImage image= readMemoryImage(readBytes(new FileInputStream("C:/Users/Administrator/Desktop/2.jpg")));
		System.out.println(image.getHeight());
		byte[] picByte = bufferedImageTobytes(image, "gif");
		byte[] picByte2 = bufferedImageTobytes(image, "jpeg");
		byte[] picByte3 = bufferedImageTobytes(image, 0.9f);
		byte[] picByte4 = newCompressImage(image, 0.4f);
		FileOutputStream f=new FileOutputStream("C:/Users/Administrator/Desktop/2-1.gif");
		FileOutputStream f2=new FileOutputStream("C:/Users/Administrator/Desktop/2-2.jpg");
		FileOutputStream f3=new FileOutputStream("C:/Users/Administrator/Desktop/2-3.jpg");
		FileOutputStream f4=new FileOutputStream("C:/Users/Administrator/Desktop/2-4.jpg");
		f.write(picByte);
		f2.write(picByte2);
		f3.write(picByte3);
		f4.write(picByte4);
		f.close();
		f2.close();
		f3.close();
		f4.close();
	}
	
    /**
     * 从内存字节数组中读取图像
     * 
     * @param imgBytes
     *            未解码的图像数据
     * @return 返回 {@link BufferedImage}
     * @throws IOException
     *             当读写错误或不识别的格式时抛出
     */
	  public static final BufferedImage readMemoryImage(byte[] imgBytes) throws IOException {
	        if (null == imgBytes || 0 == imgBytes.length)
	            throw new NullPointerException("the argument 'imgBytes' must not be null or empty");
	        // 将字节数组转为InputStream，再转为MemoryCacheImageInputStream
	        ImageInputStream imageInputstream = new MemoryCacheImageInputStream(new ByteArrayInputStream(imgBytes));
	        // 获取所有能识别数据流格式的ImageReader对象
	        Iterator it = ImageIO.getImageReaders(imageInputstream);
	        // 迭代器遍历尝试用ImageReader对象进行解码
	        while (it.hasNext()) {
	            ImageReader imageReader = it.next();
	            // 设置解码器的输入流
	            imageReader.setInput(imageInputstream, true, true);
	            // 图像文件格式后缀
	            String suffix = imageReader.getFormatName().trim().toLowerCase();
	            // 图像宽度
	            int width = imageReader.getWidth(0);
	            // 图像高度
	            int height = imageReader.getHeight(0);
	            System.out.printf("format %s,%dx%d
", suffix, width, height);
	            try {
	                // 解码成功返回BufferedImage对象
	                // 0即为对第0张图像解码(gif格式会有多张图像),前面获取宽度高度的方法中的参数0也是同样的意思
	                 return imageReader.read(0, imageReader.getDefaultReadParam());
	            } catch (Exception e) {
	                imageReader.dispose();
	                // 如果解码失败尝试用下一个ImageReader解码
	            }
	        }
	        imageInputstream.close();
	        // 没有能识别此数据的图像ImageReader对象，抛出异常
	        throw new IOException("unsupported image format");
	    }
	  
	    /**
	     * 从{@link InputStream}读取字节数组

	     * 结束时会关闭{@link InputStream}

	     * {@code in}为{@code null}时抛出{@link NullPointerException}
	     * 
	     * @param in
	     * @return 字节数组
	     * @throws IOException
	     */
	    public static final byte[] readBytes(InputStream in) throws IOException {
	        if (null == in)
	            throw new NullPointerException("the argument 'in' must not be null");
	        try {
	            int buffSize = Math.max(in.available(), 1024 * 8);
	            byte[] temp = new byte[buffSize];
	            ByteArrayOutputStream out = new ByteArrayOutputStream(buffSize);
	            int size = 0;
	            while ((size = in.read(temp)) != -1) {
	                out.write(temp, 0, size);
	            }
	            return out.toByteArray();
	        } finally {
	            in.close();
	        }
	    }
	/**
	 * 用Format对应格式中ImageIO默认参数把IMAGE打包成BYTE[]
	 * @param image
	 * @return
	 */
	private byte[] bufferedImageTobytes(BufferedImage image, String format) {
		System.out.println(format + "格式开始打包" + getCurrentTime());
		ByteArrayOutputStream out = new ByteArrayOutputStream();
		try {
			ImageIO.write(image, format, out);
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println(format + "格式完成打包-----" + getCurrentTime()
				+ "----lenth------" + out.toByteArray().length);
		return out.toByteArray();
	}

	/**
	 * 
	 * 自己设置压缩质量来把图片压缩成byte[]
	 * 
	 * @param image
	 *            压缩源图片
	 * @param quality
	 *            压缩质量，在0-1之间，
	 * @return 返回的字节数组
	 */
	private byte[] bufferedImageTobytes(BufferedImage image, float quality) {
		System.out.println("jpeg" + quality + "质量开始打包" + getCurrentTime());
		// 如果图片空，返回空
		if (image == null) {
			return null;
		}	
		// 得到指定Format图片的writer
		Iterator iter = ImageIO
				.getImageWritersByFormatName("jpeg");// 得到迭代器
		ImageWriter writer = (ImageWriter) iter.next(); // 得到writer

		// 得到指定writer的输出参数设置(ImageWriteParam )
		ImageWriteParam iwp = writer.getDefaultWriteParam();
		iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT); // 设置可否压缩
		iwp.setCompressionQuality(quality); // 设置压缩质量参数

		iwp.setProgressiveMode(ImageWriteParam.MODE_DISABLED);

		ColorModel colorModel = ColorModel.getRGBdefault();
		// 指定压缩时使用的色彩模式
		iwp.setDestinationType(new javax.imageio.ImageTypeSpecifier(colorModel,
				colorModel.createCompatibleSampleModel(16, 16)));

		// 开始打包图片，写入byte[]
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); // 取得内存输出流
		IIOImage iIamge = new IIOImage(image, null, null);
		try {
			// 此处因为ImageWriter中用来接收write信息的output要求必须是ImageOutput
			// 通过ImageIo中的静态方法，得到byteArrayOutputStream的ImageOutput
			writer.setOutput(ImageIO
					.createImageOutputStream(byteArrayOutputStream));
			writer.write(null, iIamge, iwp);
		} catch (IOException e) {
			System.out.println("write errro");
			e.printStackTrace();
		}
		System.out.println("jpeg" + quality + "质量完成打包-----" + getCurrentTime()
				+ "----lenth----" + byteArrayOutputStream.toByteArray().length);
		return byteArrayOutputStream.toByteArray();
	}

	/**
	 * 自己定义格式，得到当前系统时间
	 * 
	 * @return
	 */
	private String getCurrentTime() {
		Calendar c = new GregorianCalendar();
		int hour = c.get(Calendar.HOUR_OF_DAY);
		int min = c.get(Calendar.MINUTE);
		int second = c.get(Calendar.SECOND);
		int millsecond = c.get(Calendar.MILLISECOND);
		String time = hour + "点" + min + "分" + second + "秒" + millsecond;
		return time;
	}

	/**
	 *  通过 com.sun.image.codec.jpeg.JPEGCodec提供的编码器来实现图像压缩
	 * @param image
	 * @param quality
	 * @return
	 */
	private byte[] newCompressImage(BufferedImage image, float quality) {
		// 如果图片空，返回空
		if (image == null) {
			return null;
		}
		// 开始开始，写入byte[]
		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); // 取得内存输出流
		// 设置压缩参数
		JPEGEncodeParam param = JPEGCodec.getDefaultJPEGEncodeParam(image);
		param.setQuality(quality, false);
		// 设置编码器
		JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(
				byteArrayOutputStream, param);
		System.out.println("newCompressive" + quality + "质量开始打包"
				+ getCurrentTime());
		try {
			encoder.encode(image);
		} catch (Exception ef){
			ef.printStackTrace();
		}
		System.out.println("newCompressive" + quality + "质量打包完成"
				+ getCurrentTime() + "----lenth----"
				+ byteArrayOutputStream.toByteArray().length);
		return byteArrayOutputStream.toByteArray();

	}
	public static void main(String args[]) throws Exception {
		ImageTest test = new ImageTest();
		test.getImageSize();
	}

}