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\n", 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();
	}

}