圖像的縮略代碼

                    //Image image = ImageIO.read(is);
                    Image src=Toolkit.getDefaultToolkit().getImage(file.getPath());//可讀取丟失ICC信息的圖片
                    BufferedImage image=BufferedImageBuilder.toBufferedImage(src);//Image to BufferedImage
                    int w=image.getWidth(null);
                    int h=image.getHeight(null);
                    
                    //縮略圖的size
                    int size=getFileSize(flag);
                    if(size==0)size=h;
                    int nw=size;
                    int nh=(nw*h)/w;
                    if(nh>size){
                        nh=size;
                        nw=(nh*w)/h;
                    }                    
                    BufferedImage tag=new BufferedImage(nw,nh,BufferedImage.TYPE_INT_RGB);
                    tag.getGraphics().drawImage(image.getScaledInstance(nw, nh, Image.SCALE_SMOOTH), 0, 0, null);
                    FileOutputStream out=new FileOutputStream(imageFile);
                    JPEGImageEncoder encoder=JPEGCodec.createJPEGEncoder(out);
                    encoder.encode(tag);
                    out.close();

 以下是Image轉換BufferedImage代碼

public static BufferedImage toBufferedImage(Image image) {
        if (image instanceof BufferedImage) {
            return (BufferedImage)image;
        }
    
        // This code ensures that all the pixels in the image are loaded
        image = new ImageIcon(image).getImage();
    
        // Determine if the image has transparent pixels; for this method's
        // implementation, see e661 Determining If an Image Has Transparent Pixels
        //boolean hasAlpha = hasAlpha(image);
    
        // Create a buffered image with a format that's compatible with the screen
        BufferedImage bimage = null;
        GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
        try {
            // Determine the type of transparency of the new buffered image
            int transparency = Transparency.OPAQUE;
           /* if (hasAlpha) {
                transparency = Transparency.BITMASK;
            }*/
    
            // Create the buffered image
            GraphicsDevice gs = ge.getDefaultScreenDevice();
            GraphicsConfiguration gc = gs.getDefaultConfiguration();
            bimage = gc.createCompatibleImage(
                image.getWidth(null), image.getHeight(null), transparency);
        } catch (HeadlessException e) {
            // The system does not have a screen
        }
    
        if (bimage == null) {
            // Create a buffered image using the default color model
            int type = BufferedImage.TYPE_INT_RGB;
            //int type = BufferedImage.TYPE_3BYTE_BGR;//by wang
            /*if (hasAlpha) {
                type = BufferedImage.TYPE_INT_ARGB;
            }*/
            bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
        }
    
        // Copy image to buffered image
        Graphics g = bimage.createGraphics();
    
        // Paint the image onto the buffered image
        g.drawImage(image, 0, 0, null);
        g.dispose();
    
        return bimage;
    }

以上的方法可以生成品質較高無鋸齒的新圖像文件

還有以下方法生成縮略圖的，如果是圖像失真較大， 圖形可以用以下方法

//BufferedImage src = ImageIO.read(is);
                    Image image=Toolkit.getDefaultToolkit().getImage(file.getPath());//用它可以讀取丟失ICC信息的圖片
                    BufferedImageBuilder bib=new BufferedImageBuilder();
                    BufferedImage src=BufferedImageBuilder.toBufferedImage(image);
                    //BufferedImage src=bib.bufferImage(image);
                    int w=src.getWidth();
                    int h=src.getHeight();
                    int size=getFileSize(flag);
                    if(size==0)size=h;
                    int nw=size;
                    int nh=(nw*h)/w;
                    if(nh>size){
                        nh=size;
                        nw=(nh*w)/h;
                    }
                    
                    //縮圖的比例
                    double sx=(double)nw/w;
                    double sy=(double)nh/h;
                    AffineTransform transform=new AffineTransform();
                    transform.setToScale(sx, sy);
                    AffineTransformOp ato=new AffineTransformOp(transform,null);
                    int type=src.getColorModel().getColorSpace().getType();
                    if(type==5){
                        //type=BufferedImage.TYPE_3BYTE_BGR;
                        type=BufferedImage.TYPE_INT_RGB;
                    }else if(type==6){
                        type=BufferedImage.TYPE_BYTE_GRAY;
                    }
                    BufferedImage tag=new BufferedImage(nw, nh,type);
                    ato.filter(src, tag);
                    if(isGray&&type!=6){
                        //生成灰色圖片
                        tag=getGrayImage(tag);
                    }
                    ImageIO.write(tag, "jpeg", imageFile);
                    tag.flush();
                    src.flush();
                    is.close();

把圖片轉成灰度圖

private BufferedImage getGrayImage(BufferedImage image){
        BufferedImage dstimage=new BufferedImage(image.getWidth(),image.getHeight(),image.getType());
        Graphics2D g2=dstimage.createGraphics();
        RenderingHints hints=g2.getRenderingHints();
        g2.dispose();
        g2=null;
        ColorSpace grayCS=ColorSpace.getInstance(ColorSpace.CS_GRAY);
        ColorConvertOp colorConvertOp=new ColorConvertOp(grayCS,hints);
        colorConvertOp.filter(image, dstimage);
        return dstimage;
    }