java项目实现图片等比缩放

本文实例为大家分享了java项目实现图片等比缩放的具体代码，供大家参考，具体内容如下

package common;

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import javax.imageio.ImageIO;

public class ImageCompressionTask implements Runnable{
  
 private InputStream is;
 private String fileName;
 private int width;
 private int height;

 /**
  * 初始化参数
  * @param is 图片输入流
  * @param file 图片
  * @param fileName 图片名称
  * @param width  高
  * @param height 宽
  */
 public ImageCompressionTask(InputStream is,String fileName,int width,int height) {
  this.is=is;
  this.fileName=fileName;
  this.width=width;
  this.height=height;  
 }

 public void run() {
  // TODO Auto-generated method stub
  try{
   this.compressPic();
  }catch(Exception e){
   System.out.println("文件压缩失败"+e);
  }
  
 }
 
 private String compressPic() throws Exception{
  String path = "E:\\xie\\";//新图片存放路径
  String urlPath = path + fileName;
  BufferedImage buffImage;
  FileOutputStream output=null;
  BufferedImage compressPic=null;
  try {
   
   String imagetype = "";
   if(fileName.lastIndexOf(".") != -1){
    imagetype = fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
   }
   
   imagetype = imagetype.toLowerCase(); //文件后缀名
   output=new FileOutputStream(urlPath);
   buffImage=ImageIO.read(is);
   //图片缩放
   compressPic=compressPicMin(buffImage,width,height);
   //输出图片
   ImageIO.write(compressPic, imagetype, output);
  } finally {
   if(output!=null){
     try{
      output.close();
     }catch(IOException e){
      e.getStackTrace();
     }
   }
   if(is!=null){
     is.close();
   }
  }
  return fileName;
  
 }

  /**
  * 图片等比缩放
  *@param image 图片输入缓存流
  *@param outputWidth 图片压缩到的宽
  *@param outputHeight 图片压缩到的高
  *@return BufferedImage
  * */
 private BufferedImage compressPicMin(BufferedImage image,
 int outputWidth, int outputHeight) {
  // TODO Auto-generated method stub
  if(image==null){
   return null;
  }
  
  //如果图片本身的宽和高均小于要压缩到的宽和高，则不压缩直接返回
  if(outputWidth>image.getWidth(null)&&outputHeight>image.getHeight(null)){
   return image;
  }
  
  int newWidth;
  int newHeight;
   //宽和高等比缩放的率
  double rate1=(double)image.getWidth(null)/(double)outputWidth;
  double rate2=(double)image.getHeight(null)/(double)outputHeight;
  //控制缩放大小
  double rate=rate1<rate2  rate1:rate2;
  newWidth=(int) (image.getWidth(null)/rate);
  newHeight=(int) (image.getHeight(null)/rate);
  
  BufferedImage newImage=new BufferedImage(newWidth, newHeight,BufferedImage.TYPE_INT_RGB);
  newImage.createGraphics().drawImage(image.getScaledInstance(newWidth, outputHeight, Image.SCALE_SMOOTH), 0, 0, null);

  return newImage;
 }
 
 public int getWidth() {
  return width;
 }


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


 public int getHeight() {
  return height;
 }


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


}

创建ImageTest写一个main（）

package test1;

import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import common.ImageCompressionTask;


public class ImageTest {

 public static void main(String[] args){
  String imgName = System.currentTimeMillis() + "_" + ((int) (Math.random() * 900) + 100) + "." + "jpg";
  File f=new File("E:\\xie\\xxx.jpg");
  try {
   InputStream input = new FileInputStream(f);
   ImageCompressionTask r=new ImageCompressionTask(input, imgName, 520, 320);
   /*
    * 方法一：
    *
    Thread thread1 = new Thread(r);
    thread1.start(); // 启动线程
   */
   
   /*
    * 方法二：使用ThreadPoolExecutor创建线程池，并不提倡我们直接使用ThreadPoolExecutor
    *
    */
   /* ThreadPoolExecutor executor = new ThreadPoolExecutor(
         5, //核心池的大小（即线程池中的线程数目大于这个参数时，提交的任务会被放进任务缓存队列）
         10, //线程池最大能容忍的线程数
         200, //线程存活时间 
         TimeUnit.MILLISECONDS, //参数keepAliveTime的时间单位
         new ArrayBlockingQueue<Runnable>(5) //任务缓存队列，用来存放等待执行的任务
    );
   executor.execute(r);*/
   /*
    * 方法三：并不提倡我们直接使用ThreadPoolExecutor，而是使用Executors类中提供的几个静态方法来创建线程池
    * 以下是三个静态方法
    * Executors.newCachedThreadPool();    //创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
            * Executors.newSingleThreadExecutor();  //创建容量为1的缓冲池
            * Executors.newFixedThreadPool(int);  //创建固定容量大小的缓冲池
    */
    newCachedThreadPool().execute(r);
    //newSingleThreadExecutor().execute(r);
    //newFixedThreadPool(10).execute(r);
   System.out.println("图片上传成功");
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
 /*静态方法的具体实现
  * Executors.newCachedThreadPool()
  * 创建一个缓冲池，缓冲池容量大小为Integer.MAX_VALUE
  */
 public static ExecutorService newCachedThreadPool() {
   return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                  60L, TimeUnit.SECONDS,
                  new SynchronousQueue<Runnable>());
 }
 
 /*静态方法的具体实现
  * Executors.newSingleThreadExecutor()
  * 创建容量为1的缓冲池
  */
 public static ExecutorService newSingleThreadExecutor() {
   return new ThreadPoolExecutor(1, 1,
                 0L, TimeUnit.MILLISECONDS,
                 new LinkedBlockingQueue<Runnable>());
 }
 
 /*静态方法的具体实现
  * Executors.newFixedThreadPool(int)
  * 创建固定容量大小的缓冲池
  */
 public static ExecutorService newFixedThreadPool(int nThreads) {
   return new ThreadPoolExecutor(nThreads, nThreads,
                  0L, TimeUnit.MILLISECONDS,
                  new LinkedBlockingQueue<Runnable>());
 }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持源码搜藏网。