Java 如何在不压缩的情况下减小图像文件的大小？

您好，我正在用java编写一个代码来压缩图像文件而不压缩它，但我所能做的就是压缩文件

这是我的密码

package com.test.main;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class Main {

    public static final double byteSize = 1024;
    public static final String successDir = "E://Tmp/S";
    public static final String failureDir = "E://Tmp/F";
    public static final String tempDir = "E://Tmp/T";
    public static final String delimiter = "/";
    public static final String zipExtn = ".zip";
    public static final String filePath = "E://Tmp/_LND4320HR1.bmp";

    public static void main(String[] args) {
        double fileSizeInMB = 0.0;
        File inputFile = null;
        try {
            inputFile = new File(filePath);
            if (inputFile.exists()) {
                fileSizeInMB = ((inputFile.length() / (byteSize)) / (byteSize));
                if (fileSizeInMB < 6) {
                    writeToDir(inputFile,successDir);
                    System.out.println("Done");
                } else {

                    //Compress file
                    compressFile(inputFile);

                    inputFile =  new File(tempDir + delimiter
                            + getFileName(inputFile.getName())+ zipExtn);
                    if(inputFile.exists()){
                        fileSizeInMB = ((inputFile.length() / byteSize) / byteSize);
                        if (fileSizeInMB < 6) {
                            writeToDir(inputFile,successDir);
                            System.out.println("Done");
                        }else{
                            writeToDir(inputFile,failureDir);
                            System.out.println("Not Done");
                        }
                    }
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static String getFileName(String fileName) {
        int indexofDot = fileName.lastIndexOf(".");
        return fileName.substring(0,indexofDot);
    }

    public static void writeToDir(File inputFile,String dirPath) throws IOException{
        byte[] buffer = new byte[1024];
        FileOutputStream fos = new FileOutputStream(dirPath + delimiter
                + getFileName(inputFile.getName()) + zipExtn);
        FileInputStream fis = new FileInputStream(inputFile);
        int length;

        while ((length = fis.read(buffer)) > 0) {
            fos.write(buffer, 0, length);
        }
        //Closing operations
        fis.close();
        fos.close();
    }
    public static void compressFile(File inputFile) throws IOException{
        byte[] buffer = new byte[1024];

        FileOutputStream fos = new FileOutputStream(tempDir + delimiter
                + getFileName(inputFile.getName())+ zipExtn);
        ZipOutputStream zos = new ZipOutputStream(fos);
        ZipEntry ze = new ZipEntry(inputFile.getName());
        zos.putNextEntry(ze);
        FileInputStream fis = new FileInputStream(inputFile);
        int length;
        while ((length = fis.read(buffer)) > 0) {
            zos.write(buffer, 0, length);
        }
        //Closing operations
        zos.closeEntry();
        zos.close();
        fis.close();
        fos.close();
    }


}

package com.test.main；
导入java.io.File；
导入java.io.FileInputStream；
导入java.io.FileNotFoundException；
导入java.io.FileOutputStream；
导入java.io.IOException；
导入java.util.zip.ZipEntry；
导入java.util.zip.ZipoutStream；
公共班机{
公共静态最终双字节大小=1024；
公共静态最终字符串successDir=“E://Tmp/S”；
公共静态最终字符串failureDir=“E://Tmp/F”；
公共静态最终字符串tempDir=“E://Tmp/T”；
公共静态最终字符串分隔符=“/”；
公共静态最终字符串zipExtn=“.zip”；
公共静态最终字符串filePath=“E://Tmp/_LND4320HR1.bmp”；
公共静态void main（字符串[]args）{
double fileSizeInMB=0.0；
文件inputFile=null；
试一试{
inputFile=新文件（文件路径）；
if（inputFile.exists（））{
fileSizeInMB=（（inputFile.length（）/（byteSize））/（byteSize））；
if（fileSizeInMB<6）{
writeToDir（inputFile，successDir）；
系统输出打印项次（“完成”）；
}否则{
//压缩文件
压缩文件（inputFile）；
inputFile=新文件（tempDir+分隔符
+getFileName（inputFile.getName（））+zipExtn）；
if（inputFile.exists（））{
fileSizeInMB=（（inputFile.length（）/byteSize）/byteSize）；
if（fileSizeInMB<6）{
writeToDir（inputFile，successDir）；
系统输出打印项次（“完成”）；
}否则{
writeToDir（inputFile，failureDir）；
系统输出打印项次（“未完成”）；
}
}
}
}
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
公共静态字符串getFileName（字符串文件名）{
int indexofDot=fileName.lastIndexOf（“.”）；
返回fileName.substring（0，indexofDot）；
}
公共静态void writeToDir（文件inputFile，字符串dirPath）引发IOException{
字节[]缓冲区=新字节[1024]；
FileOutputStream fos=新的FileOutputStream（dirPath+分隔符
+getFileName（inputFile.getName（））+zipExtn）；
FileInputStream fis=新的FileInputStream（inputFile）；
整数长度；
而（（长度=fis.read（缓冲区））>0）{
fos.写入（缓冲区，0，长度）；
}
//关闭操作
fis.close（）；
fos.close（）；
}
公共静态void compressFile（File inputFile）引发IOException{
字节[]缓冲区=新字节[1024]；
FileOutputStream fos=新的FileOutputStream（tempDir+分隔符
+getFileName（inputFile.getName（））+zipExtn）；
ZipoutStream zos=新ZipoutStream（fos）；
ZipEntry ze=newzipentry（inputFile.getName（））；
佐斯·普特内森特里（泽）；
FileInputStream fis=新的FileInputStream（inputFile）；
整数长度；
而（（长度=fis.read（缓冲区））>0）{
写入（缓冲区，0，长度）；
}
//关闭操作
zos.closeEntry（）；
zos.close（）；
fis.close（）；
fos.close（）；
}
}

---

上面的代码只对文件进行了压缩，但没有压缩文件。

此程序将在不压缩图像的情况下更改图像大小

import java.awt.AlphaComposite;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;

public class ImageTest {

    private static final int IMG_WIDTH = 512;
    private static final int IMG_CLAHEIGHT = 512;

    public static void main(String[] args) {
        String filePath = "e:\\Image_DCM_PNG\\";
        try {

            File myFile = new File(filePath);
            File roots[] = myFile.listFiles();
            for (int i = 0; i < roots.length; i++) {
                System.out.println(roots[i]);
                BufferedImage originalImage = ImageIO.read(new File(filePath + roots[i].getName()));
                int type = originalImage.getType() == 0 ? BufferedImage.TYPE_INT_ARGB : originalImage.getType();

                BufferedImage resizeImageBmp = resizeImage(originalImage, type);
                ImageIO.write(resizeImageBmp, "png", new File(filePath + roots[i].getName()));
            }

        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    private static BufferedImage resizeImage(BufferedImage originalImage, int type) {
        BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_CLAHEIGHT, type);
        Graphics2D g = resizedImage.createGraphics();
        g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_CLAHEIGHT, null);
        g.dispose();
        return resizedImage;
    }

    private static BufferedImage resizeImageWithHint(BufferedImage originalImage, int type) {

        BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_CLAHEIGHT, type);
        Graphics2D g = resizedImage.createGraphics();
        g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_CLAHEIGHT, null);
        g.dispose();
        g.setComposite(AlphaComposite.Src);

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

        return resizedImage;
    }
}

导入java.awt.AlphaComposite；
导入java.awt.Graphics2D；
导入java.awt.RenderingHints；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入javax.imageio.imageio；
公共类图像测试{
专用静态最终int IMG_宽度=512；
私有静态最终整数IMG_clahight=512；
公共静态void main（字符串[]args）{
String filePath=“e:\\Image\u DCM\u PNG\\”；
试一试{
File myFile=新文件（filePath）；
文件根[]=myFile.listFiles（）；
for（int i=0；i