`

java 实现对图片的压缩生成缩略图

    博客分类：
  • java
java 
阅读更多

一位高手的上传内容中学习到的，并将其代码根据我的需求进行了修改，参考位置：http://jiangpin1987.javaeye.com/blog/749690

 

参考代码：

[java] view plaincopyprint?
  1. import java.io.*;  
  2. import java.util.logging.Level;  
  3. import java.util.logging.Logger;  
  4. import java.awt.*;  
  5. import com.sun.image.codec.jpeg.*;  
  6. import java.awt.image.BufferedImage;  
  7.   
  8. public class Img_Middle {  
  9.     public void img_change(String url, String name) {  
  10.         Tosmallerpic(url, new File(url + name), "_middle", name, 188, 165,  
  11.                 (float) 0.7);  
  12.         Tosmallerpic(url, new File(url + name), "_small", name, 45, 45,  
  13.                 (float) 0.7);  
  14.         Tosmallerpic(url, new File(url + name), "_smaller", name, 116, 100,  
  15.                 (float) 0.7);  
  16.     }  
  17.   
  18.     /** 
  19.      * * * @param f 图片所在的文件夹路径 * @param filelist 图片路径 * 
  20.      *  
  21.      * @param ext 
  22.      *            扩展名 
  23.      * @param n 
  24.      *            图片名 
  25.      * @param w 
  26.      *            目标宽 * 
  27.      * @param h 
  28.      *            目标高 * 
  29.      * @param per 
  30.      *            百分比 
  31.      */  
  32.     private static void Tosmallerpic(String f, File filelist, String ext,  
  33.             String n, int w, int h, float per) {  
  34.         Image src;  
  35.         try {  
  36.             src = javax.imageio.ImageIO.read(filelist);  
  37.             // 构造Image对象  
  38.             String img_midname = f + n.substring(0, n.indexOf(".")) + ext  
  39.                     + n.substring(n.indexOf("."));  
  40.             int old_w = src.getWidth(null); // 得到源图宽  
  41.             int old_h = src.getHeight(null);  
  42.             int new_w = 0;  
  43.             int new_h = 0; // 得到源图长  
  44.             double w2 = (old_w * 1.00) / (w * 1.00);  
  45.             double h2 = (old_h * 1.00) / (h * 1.00);  
  46.             // 图片跟据长宽留白，成一个正方形图。  
  47.             BufferedImage oldpic;  
  48.             if (old_w > old_h) {  
  49.                 oldpic = new BufferedImage(old_w, old_w,  
  50.                         BufferedImage.TYPE_INT_RGB);  
  51.             } else {  
  52.                 if (old_w < old_h) {  
  53.                     oldpic = new BufferedImage(old_h, old_h,  
  54.                             BufferedImage.TYPE_INT_RGB);  
  55.                 } else {  
  56.                     oldpic = new BufferedImage(old_w, old_h,  
  57.                             BufferedImage.TYPE_INT_RGB);  
  58.                 }  
  59.             }  
  60.             Graphics2D g = oldpic.createGraphics();  
  61.             g.setColor(Color.white);  
  62.             if (old_w > old_h) {  
  63.                 g.fillRect(0, 0, old_w, old_w);  
  64.                 g.drawImage(src, 0, (old_w - old_h) / 2, old_w, old_h,  
  65.                         Color.white, null);  
  66.             } else {  
  67.                 if (old_w < old_h) {  
  68.                     g.fillRect(0, 0, old_h, old_h);  
  69.                     g.drawImage(src, (old_h - old_w) / 2, 0, old_w, old_h,  
  70.                             Color.white, null);  
  71.                 } else {  
  72.   
  73.                     // g.fillRect(0,0,old_h,old_h);  
  74.                     g.drawImage(src.getScaledInstance(old_w, old_h,  
  75.                             Image.SCALE_SMOOTH), 0, 0, null);  
  76.                 }  
  77.             }  
  78.             g.dispose();  
  79.             src = oldpic;  
  80.             // 图片调整为方形结束  
  81.             if (old_w > w)  
  82.                 new_w = (int) Math.round(old_w / w2);  
  83.             else  
  84.                 new_w = old_w;  
  85.             if (old_h > h)  
  86.                 new_h = (int) Math.round(old_h / h2);// 计算新图长宽  
  87.             else  
  88.                 new_h = old_h;  
  89.             BufferedImage tag = new BufferedImage(new_w, new_h,  
  90.                     BufferedImage.TYPE_INT_RGB);  
  91.             // tag.getGraphics().drawImage(src,0,0,new_w,new_h,null);  
  92.             // 绘制缩小后的图  
  93.             tag.getGraphics().drawImage(  
  94.                     src.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,  
  95.                     0, null);  
  96.             FileOutputStream newimage = new FileOutputStream(img_midname); // 输出到文件流  
  97.             JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(newimage);  
  98.             JPEGEncodeParam jep = JPEGCodec.getDefaultJPEGEncodeParam(tag);  
  99.             /* 压缩质量 */  
  100.             jep.setQuality(per, true);  
  101.             encoder.encode(tag, jep);  
  102.             // encoder.encode(tag);  
  103.             // 近JPEG编码  
  104.             newimage.close();  
  105.         } catch (IOException ex) {  
  106.             Logger.getLogger(Img_Middle.class.getName()).log(Level.SEVERE,  
  107.                     null, ex);  
  108.         }  
  109.     }  
  110.       
  111.     public static void main(String args[]){        
  112.         //String n="0e5465fc-025a-458d-8383-e9ced0c1e728.jpg";      
  113.         String f="F://200903300012//pics//201006//";     
  114.         File file=new File(f);          
  115.         if(file.exists()){        
  116.             File[] filelist=file.listFiles();   
  117.             for(int i=0;i<filelist.length;i++){          
  118.                 String n=filelist[i].getName();   
  119.                 Tosmallerpic(f,filelist[i],"_middle",n,185,160,(float)0.7);    
  120.                 Tosmallerpic(f,filelist[i],"_small",n,45,45,(float)0.7);    
  121.                 Tosmallerpic(f,filelist[i],"_smaller",n,116,100,(float)0.7);    
  122.             }        
  123.         }    
  124.     }  
  125. }  


 

 

第一次修改后的代码：

 

[java] view plaincopyprint?
  1. import java.awt.Color;  
  2. import java.awt.Graphics2D;  
  3. import java.awt.Image;  
  4. import java.awt.image.BufferedImage;  
  5. import java.io.File;  
  6. import java.io.FileInputStream;  
  7. import java.io.FileNotFoundException;  
  8. import java.io.FileOutputStream;  
  9. import java.io.IOException;  
  10. import java.util.Calendar;  
  11. import java.util.Date;  
  12. import com.sun.image.codec.jpeg.ImageFormatException;  
  13. import com.sun.image.codec.jpeg.JPEGCodec;  
  14. import com.sun.image.codec.jpeg.JPEGEncodeParam;  
  15. import com.sun.image.codec.jpeg.JPEGImageEncoder;  
  16.   
  17. /** 
  18.  * * @author WQ 
  19.  *  
  20.  * @date 2011-01-14 
  21.  * @versions 1.0 图片压缩工具类 提供的方法中可以设定生成的 缩略图片的大小尺寸、压缩尺寸的比例、图片的质量等 
  22.  */  
  23. public class ImageUtil {  
  24.   
  25.     /** 
  26.      * * 图片文件读取 
  27.      *  
  28.      * @param srcImgPath 
  29.      * @return 
  30.      */  
  31.     private static BufferedImage InputImage(String srcImgPath) {  
  32.   
  33.         BufferedImage srcImage = null;  
  34.         try {  
  35.             // 构造BufferedImage对象  
  36.             File file = new File(srcImgPath);  
  37.             FileInputStream in = new FileInputStream(file);  
  38.             byte[] b = new byte[5];  
  39.             in.read(b);  
  40.             srcImage = javax.imageio.ImageIO.read(file);  
  41.         } catch (IOException e) {  
  42.             System.out.println("读取图片文件出错！" + e.getMessage());  
  43.             e.printStackTrace();  
  44.         }  
  45.         return srcImage;  
  46.     }  
  47.   
  48.     /** 
  49.      * * 将图片按照指定的图片尺寸、源图片质量压缩(默认质量为1) 
  50.      *  
  51.      * @param srcImgPath 
  52.      *            :源图片路径 
  53.      * @param outImgPath 
  54.      *            :输出的压缩图片的路径 
  55.      * @param new_w 
  56.      *            :压缩后的图片宽 
  57.      * @param new_h 
  58.      *            :压缩后的图片高 
  59.      */  
  60.     public static void Tosmallerpic(String srcImgPath, String outImgPath,  
  61.             int new_w, int new_h) {  
  62.         Tosmallerpic(srcImgPath, outImgPath, new_w, new_h, 1F);  
  63.     }  
  64.   
  65.     /** 
  66.      * 将图片按照指定的尺寸比例、源图片质量压缩(默认质量为1) 
  67.      *  
  68.      * @param srcImgPath 
  69.      *            :源图片路径 
  70.      * @param outImgPath 
  71.      *            :输出的压缩图片的路径 
  72.      * @param ratio 
  73.      *            :压缩后的图片尺寸比例 
  74.      * @param per 
  75.      *            :百分比 
  76.      */  
  77.     public static void Tosmallerpic(String srcImgPath, String outImgPath,  
  78.             float ratio) {  
  79.         Tosmallerpic(srcImgPath, outImgPath, ratio, 1F);  
  80.     }  
  81.   
  82.     /** 
  83.      * 将图片按照指定长或者宽的最大值来压缩图片(默认质量为1) 
  84.      *  
  85.      * @param srcImgPath 
  86.      *            :源图片路径 
  87.      * @param outImgPath 
  88.      *            :输出的压缩图片的路径 
  89.      * @param maxLength 
  90.      *            :长或者宽的最大值 
  91.      * @param per 
  92.      *            :图片质量 
  93.      */  
  94.     public static void Tosmallerpic(String srcImgPath, String outImgPath,  
  95.             int maxLength) {  
  96.         Tosmallerpic(srcImgPath, outImgPath, maxLength, 1F);  
  97.     }  
  98.   
  99.     /** 
  100.      * * 将图片按照指定的图片尺寸、图片质量压缩 
  101.      *  
  102.      * @param srcImgPath 
  103.      *            :源图片路径 
  104.      * @param outImgPath 
  105.      *            :输出的压缩图片的路径 
  106.      * @param new_w 
  107.      *            :压缩后的图片宽 
  108.      * @param new_h 
  109.      *            :压缩后的图片高 
  110.      * @param per 
  111.      *            :百分比 
  112.      */  
  113.     public static void Tosmallerpic(String srcImgPath, String outImgPath,  
  114.             int new_w, int new_h, float per) {  
  115.         // 得到图片  
  116.         BufferedImage src = InputImage(srcImgPath);  
  117.         int old_w = src.getWidth();  
  118.         // 得到源图宽  
  119.         int old_h = src.getHeight();  
  120.         // 得到源图长  
  121.         // 根据原图的大小生成空白画布  
  122.         BufferedImage tempImg = new BufferedImage(old_w, old_h,  
  123.                 BufferedImage.TYPE_INT_RGB);  
  124.         // 在新的画布上生成原图的缩略图  
  125.         Graphics2D g = tempImg.createGraphics();  
  126.         g.setColor(Color.white);  
  127.         g.fillRect(0, 0, old_w, old_h);  
  128.         g.drawImage(src, 0, 0, old_w, old_h, Color.white, null);  
  129.         g.dispose();  
  130.         BufferedImage newImg = new BufferedImage(new_w, new_h,  
  131.                 BufferedImage.TYPE_INT_RGB);  
  132.         newImg.getGraphics().drawImage(  
  133.                 tempImg.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,  
  134.                 0, null);  
  135.         // 调用方法输出图片文件  
  136.         OutImage(outImgPath, newImg, per);  
  137.     }  
  138.   
  139.     /** 
  140.      * * 将图片按照指定的尺寸比例、图片质量压缩 
  141.      *  
  142.      * @param srcImgPath 
  143.      *            :源图片路径 
  144.      * @param outImgPath 
  145.      *            :输出的压缩图片的路径 
  146.      * @param ratio 
  147.      *            :压缩后的图片尺寸比例 
  148.      * @param per 
  149.      *            :百分比 
  150.      */  
  151.     public static void Tosmallerpic(String srcImgPath, String outImgPath,  
  152.             float ratio, float per) {  
  153.         // 得到图片  
  154.         BufferedImage src = InputImage(srcImgPath);  
  155.         int old_w = src.getWidth();  
  156.         // 得到源图宽  
  157.         int old_h = src.getHeight();  
  158.         // 得到源图长  
  159.         int new_w = 0;  
  160.         // 新图的宽  
  161.         int new_h = 0;  
  162.         // 新图的长  
  163.         BufferedImage tempImg = new BufferedImage(old_w, old_h,  
  164.                 BufferedImage.TYPE_INT_RGB);  
  165.         Graphics2D g = tempImg.createGraphics();  
  166.         g.setColor(Color.white);  
  167.         // 从原图上取颜色绘制新图g.fillRect(0, 0, old_w, old_h);  
  168.         g.drawImage(src, 0, 0, old_w, old_h, Color.white, null);  
  169.         g.dispose();  
  170.         // 根据图片尺寸压缩比得到新图的尺寸new_w = (int) Math.round(old_w * ratio);  
  171.         new_h = (int) Math.round(old_h * ratio);  
  172.         BufferedImage newImg = new BufferedImage(new_w, new_h,  
  173.                 BufferedImage.TYPE_INT_RGB);  
  174.         newImg.getGraphics().drawImage(  
  175.                 tempImg.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,  
  176.                 0, null);  
  177.         // 调用方法输出图片文件OutImage(outImgPath, newImg, per);  
  178.     }  
  179.   
  180.     /** 
  181.      * * 指定长或者宽的最大值来压缩图片 
  182.      *  
  183.      * @param srcImgPath 
  184.      *            :源图片路径 
  185.      * @param outImgPath 
  186.      *            :输出的压缩图片的路径 
  187.      * @param maxLength 
  188.      *            :长或者宽的最大值 
  189.      * @param per 
  190.      *            :图片质量 
  191.      */  
  192.     public static void Tosmallerpic(String srcImgPath, String outImgPath,  
  193.             int maxLength, float per) {  
  194.         // 得到图片  
  195.         BufferedImage src = InputImage(srcImgPath);  
  196.         int old_w = src.getWidth();  
  197.         // 得到源图宽  
  198.         int old_h = src.getHeight();  
  199.         // 得到源图长  
  200.         int new_w = 0;  
  201.         // 新图的宽  
  202.         int new_h = 0;  
  203.         // 新图的长  
  204.         BufferedImage tempImg = new BufferedImage(old_w, old_h,  
  205.                 BufferedImage.TYPE_INT_RGB);  
  206.         Graphics2D g = tempImg.createGraphics();  
  207.         g.setColor(Color.white);  
  208.         // 从原图上取颜色绘制新图  
  209.         g.fillRect(0, 0, old_w, old_h);  
  210.         g.drawImage(src, 0, 0, old_w, old_h, Color.white, null);  
  211.         g.dispose();  
  212.         // 根据图片尺寸压缩比得到新图的尺寸  
  213.         if (old_w > old_h) {  
  214.             // 图片要缩放的比例  
  215.             new_w = maxLength;  
  216.             new_h = (int) Math.round(old_h * ((float) maxLength / old_w));  
  217.         } else {  
  218.             new_w = (int) Math.round(old_w * ((float) maxLength / old_h));  
  219.             new_h = maxLength;  
  220.         }  
  221.         BufferedImage newImg = new BufferedImage(new_w, new_h,  
  222.                 BufferedImage.TYPE_INT_RGB);  
  223.         newImg.getGraphics().drawImage(  
  224.                 tempImg.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0,  
  225.                 0, null);  
  226.         // 调用方法输出图片文件  
  227.         OutImage(outImgPath, newImg, per);  
  228.     }  
  229.   
  230.     /** 
  231.      * * 将图片文件输出到指定的路径，并可设定压缩质量 
  232.      *  
  233.      * @param outImgPath 
  234.      * @param newImg 
  235.      * @param per 
  236.      */  
  237.     private static void OutImage(String outImgPath, BufferedImage newImg,  
  238.             float per) {  
  239.         // 判断输出的文件夹路径是否存在，不存在则创建  
  240.         File file = new File(outImgPath);  
  241.         if (!file.getParentFile().exists()) {  
  242.             file.getParentFile().mkdirs();  
  243.         }// 输出到文件流  
  244.         try {  
  245.             FileOutputStream newimage = new FileOutputStream(outImgPath);  
  246.             JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(newimage);  
  247.             JPEGEncodeParam jep = JPEGCodec.getDefaultJPEGEncodeParam(newImg);  
  248.             // 压缩质量  
  249.             jep.setQuality(per, true);  
  250.             encoder.encode(newImg, jep);  
  251.             newimage.close();  
  252.         } catch (FileNotFoundException e) {  
  253.             // TODO Auto-generated catch blocke.printStackTrace();  
  254.         } catch (ImageFormatException e) {  
  255.             // TODO Auto-generated catch blocke.printStackTrace();  
  256.         } catch (IOException e) {  
  257.             // TODO Auto-generated catch blocke.printStackTrace();  
  258.         }  
  259.     }  
  260.   
  261.     public static void main(String args[]) {  
  262.         String f = "c:/img/";  
  263.         File file = new File(f);  
  264.         if (file.exists()) {  
  265.             File[] filelist = file.listFiles();  
  266.             for (int i = 0; i < filelist.length; i++) {  
  267.                 File fi = filelist[i];  
  268.                 System.out.println(fi.length());  
  269.                 String n = filelist[i].getName();  
  270.                 // Tosmallerpic(f, filelist[i], "_ratio_small", n,  
  271.                 // 0.303,(float)0.7);  
  272.                 // Tosmallerpic(f, filelist[i], "_ratio_smaller", n,  
  273.                 // 0.083,(float)0.7);  
  274.             }  
  275.         }  
  276.         String srcImg = "c:/img/car_2.jpg";  
  277.         String tarDir = "c:/img/newImg/";  
  278.         long startTime = new Date().getTime();  
  279.         Tosmallerpic(srcImg, tarDir + "car_1_maxLength_1.jpg", 400);  
  280.         Tosmallerpic(srcImg, tarDir + "car_1_maxLength_2.jpg", 0.5F);  
  281.         Tosmallerpic(srcImg, tarDir + "car_1_maxLength_3.jpg", 400, 500);  
  282.         Tosmallerpic(srcImg, tarDir + "car_1_maxLength_11.jpg", 400, 0.7F);  
  283.         Tosmallerpic(srcImg, tarDir + "car_1_maxLength_22.jpg", 0.5F, 0.8F);  
  284.         Tosmallerpic(srcImg, tarDir + "car_1_maxLength_33.jpg", 400, 500, 0.8F);  
  285.         System.out.println(new Date().getTime() - startTime);  
  286.     }  
  287. }  


 

 

第二次修改，只是对长宽尺寸压缩，按原图片质量

[java] view plaincopyprint?
  1. import java.awt.Graphics2D;  
  2. import java.awt.Image;  
  3. import java.awt.image.BufferedImage;  
  4. import java.io.File;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileNotFoundException;  
  7. import java.io.IOException;  
  8. import javax.imageio.ImageIO;  
  9.   
  10. /** 
  11.  * * @author WQ * @date 2011-01-14 * @versions 1.0 图片压缩工具类 提供的方法中可以设定生成的 
  12.  * 缩略图片的大小尺寸等 
  13.  */  
  14. public class ImageUtil {  
  15.     /** * 图片文件读取 * * @param srcImgPath * @return */  
  16.     private static BufferedImage InputImage(String srcImgPath) {  
  17.         BufferedImage srcImage = null;  
  18.         try {  
  19.             FileInputStream in = new FileInputStream(srcImgPath);  
  20.             srcImage = javax.imageio.ImageIO.read(in);  
  21.         } catch (IOException e) {  
  22.             System.out.println("读取图片文件出错！" + e.getMessage());  
  23.             e.printStackTrace();  
  24.         }  
  25.         return srcImage;  
  26.     }  
  27.   
  28.     /** 
  29.      * * 将图片按照指定的图片尺寸压缩 * * @param srcImgPath :源图片路径 * @param outImgPath * 
  30.      * :输出的压缩图片的路径 * @param new_w * :压缩后的图片宽 * @param new_h * :压缩后的图片高 
  31.      */  
  32.     public static void compressImage(String srcImgPath, String outImgPath,  
  33.             int new_w, int new_h) {  
  34.         BufferedImage src = InputImage(srcImgPath);  
  35.         disposeImage(src, outImgPath, new_w, new_h);  
  36.     }  
  37.   
  38.     /** 
  39.      * * 指定长或者宽的最大值来压缩图片 * * @param srcImgPath * :源图片路径 * @param outImgPath * 
  40.      * :输出的压缩图片的路径 * @param maxLength * :长或者宽的最大值 
  41.      */  
  42.     public static void compressImage(String srcImgPath, String outImgPath,  
  43.             int maxLength) {  
  44.         // 得到图片  
  45.         BufferedImage src = InputImage(srcImgPath);  
  46.         if (null != src) {  
  47.             int old_w = src.getWidth();  
  48.             // 得到源图宽  
  49.             int old_h = src.getHeight();  
  50.             // 得到源图长  
  51.             int new_w = 0;  
  52.             // 新图的宽  
  53.             int new_h = 0;  
  54.             // 新图的长  
  55.             // 根据图片尺寸压缩比得到新图的尺寸  
  56.             if (old_w > old_h) {  
  57.                 // 图片要缩放的比例  
  58.                 new_w = maxLength;  
  59.                 new_h = (int) Math.round(old_h * ((float) maxLength / old_w));  
  60.             } else {  
  61.                 new_w = (int) Math.round(old_w * ((float) maxLength / old_h));  
  62.                 new_h = maxLength;  
  63.             }  
  64.             disposeImage(src, outImgPath, new_w, new_h);  
  65.         }  
  66.     }  
  67.   
  68.     /** * 处理图片 * * @param src * @param outImgPath * @param new_w * @param new_h */  
  69.     private synchronized static void disposeImage(BufferedImage src,  
  70.             String outImgPath, int new_w, int new_h) {  
  71.         // 得到图片  
  72.         int old_w = src.getWidth();  
  73.         // 得到源图宽  
  74.         int old_h = src.getHeight();  
  75.         // 得到源图长  
  76.         BufferedImage newImg = null;  
  77.         // 判断输入图片的类型  
  78.         switch (src.getType()) {  
  79.         case 13:  
  80.             // png,gifnewImg = new BufferedImage(new_w, new_h,  
  81.             // BufferedImage.TYPE_4BYTE_ABGR);  
  82.             break;  
  83.         default:  
  84.             newImg = new BufferedImage(new_w, new_h, BufferedImage.TYPE_INT_RGB);  
  85.             break;  
  86.         }  
  87.         Graphics2D g = newImg.createGraphics();  
  88.         // 从原图上取颜色绘制新图  
  89.         g.drawImage(src, 0, 0, old_w, old_h, null);  
  90.         g.dispose();  
  91.         // 根据图片尺寸压缩比得到新图的尺寸  
  92.         newImg.getGraphics().drawImage(  
  93.                 src.getScaledInstance(new_w, new_h, Image.SCALE_SMOOTH), 0, 0,  
  94.                 null);  
  95.         // 调用方法输出图片文件  
  96.         OutImage(outImgPath, newImg);  
  97.     }  
  98.   
  99.     /** 
  100.      * * 将图片文件输出到指定的路径，并可设定压缩质量 * * @param outImgPath * @param newImg * @param 
  101.      * per 
  102.      */  
  103.     private static void OutImage(String outImgPath, BufferedImage newImg) {  
  104.         // 判断输出的文件夹路径是否存在，不存在则创建  
  105.         File file = new File(outImgPath);  
  106.         if (!file.getParentFile().exists()) {  
  107.             file.getParentFile().mkdirs();  
  108.         }// 输出到文件流  
  109.         try {  
  110.             ImageIO.write(newImg, outImgPath.substring(outImgPath  
  111.                     .lastIndexOf(".") + 1), new File(outImgPath));  
  112.         } catch (FileNotFoundException e) {  
  113.             e.printStackTrace();  
  114.         } catch (IOException e) {  
  115.             e.printStackTrace();  
  116.         }  
  117.     }  
  118. }  
分享到：
| ORACLE函数实现按汉字拼音首字母查询
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java生成高清缩略图不丢真，java压缩图片

    网上找的缩略图生成方法都不够清晰，于是决定自己研究和改进生成缩略图方法。此方法压缩后的图片小，清晰度高，压缩速度快。5000张图片大概抽根烟的功夫就压缩完了。高清的哦。各种参数都是可配的，方便移植到自己...

    java视频生成图片（缩略图）-实例-（指定时间）

    6. **Java bindings for FFmpeg：** 如果不希望通过命令行接口，还可以使用Java对FFmpeg的绑定库，如JAVE（Java Audio Video Encoder），它提供了一个友好的API来执行FFmpeg的任务，包括生成缩略图。 7. **处理步骤...

    thumbnailator java用于图片压缩 生成缩略图 添加水印等

    thumbnailator（包括jar包跟api） java用于图片压缩 生成缩略图 添加水印等 这是我见过最好的压缩工具了 使用方法： Thumbnails.of(new File("path/to/directory").listFiles()) .size(640, 480) .outputFormat(...

    生成缩略图（压缩图片）

    在IT行业中，生成缩略图和压缩图片是常见的图像处理任务，尤其在网站开发、社交媒体分享、移动应用以及存储和传输大量图像时显得尤为重要。本文将深入探讨如何生成缩略图以及有效地压缩图片，帮助您解决相关问题。 ...

    java图片生成缩略图

    * 压缩图片方法 * * @param oldFile 将要压缩的图片 * @param width 压缩宽 * @param height 压缩高 * @param quality 压缩清晰度 建议为1.0 * @param smallIcon 压缩图片后,添加的扩展名（在图片后缀名前添加...

    可以控制宽高大小的缩略图生成函数

    可以控制宽高大小的缩略图生成函数

    java生成缩略图.pdf

    在Java中生成缩略图是一项常见的任务，尤其是在开发Web应用或者需要处理用户上传图片的系统中。这个过程涉及对原始图像进行重新尺寸调整，以创建一个较小的版本，通常用于预览或节省存储空间。在提供的代码片段中，...

    jSP上传图片生成缩略图

    实现"jSP上传图片生成缩略图"，首先需要处理文件上传。jspSmartUpload.jar很可能是一个用于文件上传的库，如SmartUpload，这是一个Java组件，提供了一套完整的文件上传解决方案，包括上传进度显示、文件大小限制、多...

    上传图片(缩略图)

    - **质量控制**：生成缩略图时，可以调整JPEG的压缩质量或PNG的压缩级别，以平衡图片质量与文件大小。 - **裁剪与填充**：如果需要特定尺寸的缩略图，可能需要裁剪多余部分或填充空白区域，保持原始画面的关键内容...

    图片生成缩略图片

    - **服务器端生成**：服务器在接收到请求后，通过编程语言（如Python的PIL库、Java的ImageIO、Node.js的sharp库等）处理图片，生成缩略图并返回给客户端。这种方式可以保证所有用户获得一致的体验，但服务器负载...

    JSP上传图片并生成缩略图

    在本文中，我们将深入探讨如何使用JSP和jspsmart组件来实现图片上传及生成缩略图的功能。jspsmart组件是一个强大的文件上传工具，它提供了便捷的API用于处理文件上传，包括验证文件类型和大小，以及错误处理。 首先...

    详解Java实现批量压缩图片裁剪压缩多种尺寸缩略图一键批量上传图片

    2. Java实现批量压缩图片裁剪压缩多种尺寸缩略图一键批量上传图片的实现思路：先把本地磁盘目录中的所有图片资源通过IO流读出来，读到内存中，然后对图片的名称根据定义好的业务规则解析，生成不同的图片名，然后对...

    java代码保存宽高不变压缩图片(失真不大).docx

    EGCodec.createJPEGEncoder(out); JPEGEncodeParam param = ...总的来说，这段Java代码提供了一个实用的工具，能够在不失真过大（通过调整压缩质量）的前提下，根据图片原始大小智能地压缩图片，满足不同场景的需求。

    Java做图片压缩的代码

    在Java编程环境中，图片压缩和生成缩略图是常见的任务，尤其在处理大量图像数据或者优化网站性能时显得尤为重要。本文将深入探讨如何利用Java进行图片处理，包括压缩和生成缩略图的关键技术。 首先，Java提供了丰富...

    jsp中生成图片缩略图的代码

    然而，需要注意的是，在实际部署中，应考虑资源消耗和性能优化，例如使用缓存机制避免重复生成缩略图，以及优化图像压缩参数以达到更好的视觉效果和加载速度。此外，对于动态生成的缩略图，还应确保处理过程中的异常...

    java代码实现图片压缩

    实现图片的压缩 1.按照固定的比例缩放图片 2.以宽度为基准等比例放缩图片 3.以高度为基准，等比例缩放图片 4.按照最大高度限制，生成最大的等比例缩略图

    java实现图片压缩功能源码

    java上传图片功能，图片太大，等比例压缩算法(原尺寸压缩)

    生成缩略图Activex源码

    3. 图像质量优化：在生成缩略图时，为了减少文件大小，可能会对图片进行质量压缩。这涉及到JPEG、PNG等格式的编码参数调整，以平衡图片质量和文件大小。 4. 输出保存：最后，生成的缩略图会被保存为新的文件，其...

    ThumbNailator缩略图生成实验

    4. **质量控制**：在生成缩略图时，为了减小文件大小，可以调整JPEG的质量因子或选择不同的压缩算法，平衡图像质量和文件大小。 5. **保存和展示**：将生成的缩略图保存到服务器，然后在JSP页面上显示。可以提供预览...

    java高清处理图片

    为了解决这一问题，本篇将详细介绍如何使用ImageMagick及其Java接口JMagick来高效地处理图片，并生成高质量的缩略图及水印图片。 #### ImageMagick简介 ImageMagick是一款强大的跨平台图像处理工具，它支持多种...

Magicbox
Global site tag (gtag.js) - Google Analytics