如何在java中调整图像大小？

您好，我有一个二维码图像，我想调整它的大小，当我尝试使用此代码将其调整为一个小图像时，我总是会得到一个模糊的图像，当我扫描二维码时，二维码不再有效，但当我调整为具有相同代码的大尺寸图像时，效果良好：

public BufferedImage getScaledInstance(BufferedImage img,
                                   int targetWidth,
                                   int targetHeight,
                                   Object hint,
                                   boolean higherQuality)
{
int type = (img.getTransparency() == Transparency.OPAQUE) ?
    BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
BufferedImage ret = (BufferedImage)img;
int w, h;
if (higherQuality) {
    // Use multi-step technique: start with original size, then
    // scale down in multiple passes with drawImage()
    // until the target size is reached
    w = img.getWidth();
    h = img.getHeight();
} else {
    // Use one-step technique: scale directly from original
    // size to target size with a single drawImage() call
    w = targetWidth;
    h = targetHeight;
}

do {
    if (higherQuality && w > targetWidth) {
        w /= 2;
        if (w < targetWidth) {
            w = targetWidth;
        }
    }

    if (higherQuality && h > targetHeight) {
        h /= 2;
        if (h < targetHeight) {
            h = targetHeight;
        }
    }

    BufferedImage tmp = new BufferedImage(w, h, type);
    Graphics2D g2 = tmp.createGraphics();
    g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
    //        g2.setRenderingHint(RenderingHints.KEY_DITHERING, hint);
    g2.drawImage(ret, 0, 0, w, h, null);
    g2.dispose();

    ret = tmp;
} while (w != targetWidth || h != targetHeight);

return ret;
}

public buffereImage getScaledInstance（buffereImage img，
int targetWidth，
int targetHeight，
对象提示，
布尔值（高质量）
{
int type=（img.getTransparency（）==Transparency.不透明）？
BufferedImage.TYPE_INT_RGB:BufferedImage.TYPE_INT_ARGB；
BuffereImage ret=（BuffereImage）img；
int w，h；
如果（高质量）{
//使用多步骤技术：从原始尺寸开始，然后
//使用drawImage（）在多个过程中按比例缩小
//直到达到目标大小
w=img.getWidth（）；
h=img.getHeight（）；
}否则{
//使用一步技术：直接从原始图像缩放
//通过单个drawImage（）调用将大小设置为目标大小
w=目标宽度；
h=目标光；
}
做{
if（高质量和宽>目标宽度）{
w/=2；
如果（wTargetLight）{
h/=2；
如果（h<目标光）{
h=目标光；
}
}
BuffereImage tmp=新的BuffereImage（w、h、类型）；
Graphics2D g2=tmp.createGraphics（）；
g2.setRenderingHint（RenderingHints.KEY\u插值，hint）；
//g2.setRenderingHint（renderingHits.KEY\u抖动，提示）；
g2.drawImage（ret，0，0，w，h，null）；
g2.dispose（）；
ret=tmp；
}而（w！=目标宽度| | h！=目标高度）；
返回ret；
}

---

问题是什么，我不太明白，请至少给我一个提示，谢谢你

请查看此图像。GetScaleInstance（）详细信息可在此答案中找到：

---

希望它对我有所帮助

我写了这个我个人也使用的类。我希望代码是直截了当的

import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.image.CropImageFilter;
import java.awt.image.FilteredImageSource;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JComponent;


public class ImageScaler {

        private ImageIcon originalImage;
        private ImageIcon scaledImage;

        public ImageScaler(Image image) {
                this.originalImage = new ImageIcon(image);
        }

        public ImageScaler(String fileName) {
                originalImage = new ImageIcon(fileName);
        }

        public void createScaledImage(int size, ScalingDirection scalingDirection) {
                if (scalingDirection == ScalingDirection.HORIZONTAL) {
                        scaledImage = new ImageIcon(originalImage.getImage().getScaledInstance(size, -1, Image.SCALE_SMOOTH));
                } else {
                        scaledImage = new ImageIcon(originalImage.getImage().getScaledInstance(-1, size, Image.SCALE_SMOOTH));
                }       
        }

        public void createScaledImage(int size, ScalingDirection scalingDirection, int scale) {
                if (scalingDirection == ScalingDirection.HORIZONTAL) {
                        scaledImage = new ImageIcon(originalImage.getImage().getScaledInstance(size, -1, scale));
                } else {
                        scaledImage = new ImageIcon(originalImage.getImage().getScaledInstance(-1, size, scale));
                }
        }

        public void createScaledImage(int width, int height, ScaleType scaleType) {
                int imageWidth = originalImage.getImage().getWidth(null);
                int imageHeight = originalImage.getImage().getHeight(null);
                double originalImageRatio = imageWidth / (double) imageHeight;
                double scaledImageRatio = width / (double) height;

                if(scaleType == ScaleType.FIT) {
                        if(imageHeight - (Math.abs(imageWidth - width) / originalImageRatio) <= height) {
                                scaledImage = new ImageIcon(originalImage.getImage().getScaledInstance(width, -1, Image.SCALE_SMOOTH));
                        } else if(imageWidth - (Math.abs(imageHeight - height) * originalImageRatio) <= width) {
                                scaledImage = new ImageIcon(originalImage.getImage().getScaledInstance(-1, height, Image.SCALE_SMOOTH));
                        }
                } else if(scaleType == ScaleType.FILL) {
                        if(imageHeight - (Math.abs(imageWidth - width) / originalImageRatio) >= height) {
                                scaledImage = new ImageIcon(originalImage.getImage().getScaledInstance(width, -1, Image.SCALE_SMOOTH));
                                int thumbHeight = scaledImage.getImage().getHeight(null);

                                // Crop the image
                                scaledImage = new ImageIcon(Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(scaledImage.getImage().getSource(), new CropImageFilter(0, (thumbHeight-height)/2, width, height))));
                        } else if(imageWidth - (Math.abs(imageHeight - height) * originalImageRatio) >= width) {
                                scaledImage = new ImageIcon(originalImage.getImage().getScaledInstance(-1, height, Image.SCALE_SMOOTH));
                                int thumbWidth = scaledImage.getImage().getWidth(null);

                                // Crop the image
                                scaledImage = new ImageIcon(Toolkit.getDefaultToolkit().createImage(new FilteredImageSource(scaledImage.getImage().getSource(), new CropImageFilter((thumbWidth-width)/2, 0, width, height))));
                        }               
                }
        }

        public void saveScaledImage(File file, ImageType imageType) {
                if (scaledImage != null) {
                        BufferedImage bi = new BufferedImage(scaledImage.getIconWidth(), scaledImage.getIconHeight(), BufferedImage.TYPE_INT_RGB);
                        Graphics g = bi.getGraphics();
                        g.drawImage(scaledImage.getImage(), 0, 0, null);
                        try {
                                ImageIO.write(bi, imageType.value(), file);
                        } catch (IOException ioe) {
                                System.out.println("Error occured saving scaled image");
                        }
                } else {
                        System.out.println("Scaled image has not yet been created");
                }
        }

        public void saveOriginalImage(File file, ImageType imageType) {
                if (originalImage != null) {
                        BufferedImage bi = new BufferedImage(originalImage.getIconWidth(), originalImage.getIconHeight(), BufferedImage.TYPE_INT_RGB);
                        Graphics g = bi.getGraphics();
                        g.drawImage(originalImage.getImage(), 0, 0, null);
                        try {
                                ImageIO.write(bi, imageType.value(), file);
                        } catch (IOException ioe) {
                                System.out.println("Error occured saving original image");
                        }
                } else {
                        System.out.println("Original image has not yet been created");
                }
        }

        // ENUMS
        public enum ScalingDirection {VERTICAL, HORIZONTAL};
        public enum ScaleType {FIT, FILL};
        public enum ImageType {
                IMAGE_JPEG ("jpeg"),
                IMAGE_JPG ("jpg"),
                IMAGE_PNG ("png");

                private String value = null;

                ImageType(String value) {
                        this.value = value;
                }

                String value() {
                        return value;
                }
        };
}   

/**
 * scale image
 * 
 * @param sbi image to scale
 * @param imageType type of image
 * @param dWidth width of destination image
 * @param dHeight height of destination image
 * @param fWidth x-factor for transformation / scaling
 * @param fHeight y-factor for transformation / scaling
 * @return scaled image
 */
public static BufferedImage scale(BufferedImage sbi, int imageType, int dWidth, int dHeight, double fWidth, double fHeight) {
    BufferedImage dbi = null;
    if(sbi != null) {
        dbi = new BufferedImage(dWidth, dHeight, imageType);
        Graphics2D g = dbi.createGraphics();
        AffineTransform at = AffineTransform.getScaleInstance(fWidth, fHeight);
        g.drawRenderedImage(sbi, at);
    }
    return dbi;
}

导入java.awt.Graphics；
导入java.awt.Image；
导入java.awt.Toolkit；
导入java.awt.image.buffereImage；
导入java.awt.image.CropImageFilter；
导入java.awt.image.FilteredImageSource；
导入java.io.File；
导入java.io.IOException；
导入javax.imageio.imageio；
导入javax.swing.ImageIcon；
导入javax.swing.JComponent；
公共类图像定标器{
私人图像图标原始图像；
私有图像图标缩放图像；
公共图像缩放器（图像）{
this.originalImage=新图像图标（图像）；
}
公共ImageScaler（字符串文件名）{
originalImage=新图像图标（文件名）；
}
public void CreateScaleImage（整数大小，缩放方向缩放方向）{
if（scalingDirection==scalingDirection.HORIZONTAL）{
scaledImage=新图像图标（originalImage.getImage（）.getScaledInstance（size，-1，Image.SCALE_SMOOTH））；
}否则{
scaleImage=新图像图标（originalImage.getImage（）.getScaledInstance（-1，size，Image.SCALE_SMOOTH））；
}       
}
public void CreateScaleImage（整数大小、缩放方向缩放方向、整数缩放）{
if（scalingDirection==scalingDirection.HORIZONTAL）{
scaleImage=新图像图标（originalImage.getImage（）.getScaledInstance（大小，-1，比例））；
}否则{
scaleImage=新图像图标（originalImage.getImage（）.getScaledInstance（-1，大小，比例））；
}
}
public void createScaleImage（int-width、int-height、ScaleType-ScaleType）{
int imageWidth=originalImage.getImage（）.getWidth（null）；
int-imageHeight=originalImage.getImage（）.getHeight（null）；
双重原始图像=图像宽度/（双重）图像高度；
双刻度图像比率=宽度/（双）高度；
if（scaleType==scaleType.FIT）{
if（图像高度-（数学abs（图像宽度-宽度）/原始图像）=宽度）{
scaleImage=新图像图标（originalImage.getImage（）.getScaledInstance（-1，高度，图像。缩放平滑））；
int thumbWidth=scaleImage.getImage（）.getWidth（null）；
//裁剪图像
ScaleImage=new ImageIcon（Toolkit.getDefaultToolkit（）.createImage（new FilteredImageSource（ScaleImage.getImage（）.getSource（），new CropImageFilter（（拇指宽度）/2,0，宽度，高度））；
}               
}
}
public void saveScaleImage（文件文件，ImageType ImageType）{
if（scaleImage！=null）{
BuffereImage bi=新的BuffereImage（scaleImage.getIconWidth（），scaleImage.getIconHeight（），BuffereImage.TYPE_INT_RGB）；
Graphics g=bi.getGraphics（）；
g、 drawImage（scaleImage.getImage（），0，0，null）；
试一试{
写入（bi，imageType.value（），文件）；
}捕获（ioe异常ioe）{
System.out.println（“保存缩放图像时出错”）；
}
}否则{
System.out.println（“缩放图像尚未创建”）；
}
}
public void saveOriginalImage（文件文件，ImageType ImageType）{
if（originalImage！=null）{
BuffereImage bi=新的BuffereImage（originalImage.getIconWidth（），originalImage.getIconHeight（），buffereImage.TYPE_INT_RGB）；
Graphics g=bi.getGraphics（）；
g、 drawImage（originalImage.getImage（），0,0，
    public static BufferedImage resizeImg(BufferedImage img, int newW, int newH)
    {
    int w = img.getWidth();
    int h = img.getHeight();
    BufferedImage dimg = new BufferedImage(newW, newH, img.getType());
    Graphics2D g = dimg.createGraphics();
    g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
            RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    g.drawImage(img, 0, 0, newW, newH, 0, 0, w, h, null);
    g.dispose();
    return dimg;      
   }

public static BufferedImage scale(BufferedImage imageToScale, int dWidth, int dHeight) {
        BufferedImage scaledImage = null;
        if (imageToScale != null) {
            scaledImage = new BufferedImage(dWidth, dHeight, imageToScale.getType());
            Graphics2D graphics2D = scaledImage.createGraphics();
            graphics2D.drawImage(imageToScale, 0, 0, dWidth, dHeight, null);
            graphics2D.dispose();
        }
        return scaledImage;
    }

graphics2D.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
graphics2D.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
graphics2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);

drawImage(BufferedImage image, int x, int y, int width, int height, ImageObserver observer)