Java 压缩后显示图像

在我的代码中，我提供了一个输入图像并将其转换为字符串。字符串被压缩和解压缩。解压缩后，字符串被转换为图像并显示。这里的问题是，我需要在压缩后显示图像。我已经为此编写了代码。但它通过告诉“不是jpeg文件”来显示错误消息

我的代码：

ImageEncode.java

public class ImageEncode {

    public ImageEncode() throws Exception {
        try {
            File imageFile = new File("C:\\Users\\user\\Desktop\\encryption\\original.jpg");
            String img = imageToBase64String(imageFile);

            System.out.println("Converted String " + img);
            //Compression
            byte[] compressed = compress(img);
            String dd = MyBase64.encode(compressed);

            ByteArrayInputStream bis1 = new ByteArrayInputStream(compressed);
            Iterator<?> readers1 = ImageIO.getImageReadersByFormatName("jpg");

            //ImageIO is a class containing static methods for locating ImageReaders
            //and ImageWriters, and performing simple encoding and decoding. 

            ImageReader reader1 = (ImageReader) readers1.next();
            Object source1 = bis1;
            ImageInputStream iis1 = ImageIO.createImageInputStream(source1);
            reader1.setInput(iis1, true);
            ImageReadParam param1 = reader1.getDefaultReadParam();

            Image image11 = reader1.read(0, param1);
            //got an image file

            BufferedImage bufferedImage1 = new BufferedImage(image11.getWidth(null), image11.getHeight(null), BufferedImage.TYPE_INT_RGB);
            //bufferedImage is the RenderedImage to be written

            Graphics2D g21 = bufferedImage1.createGraphics();
            g21.drawImage(image11, null, null);

            File imageFile11 = new File("C:\\Users\\user\\Desktop\\encryption\\compress.jpg");
            ImageIO.write(bufferedImage1, "jpg", imageFile11);

            //Decompression
            String dcr = decompress(compressed);

            System.out.println("Converted String1 " + dcr);
            byte[] d = MyBase64.decode(dcr);

            ByteArrayInputStream bis = new ByteArrayInputStream(d);
            Iterator<?> readers = ImageIO.getImageReadersByFormatName("jpg");

            //ImageIO is a class containing static methods for locating ImageReaders
            //and ImageWriters, and performing simple encoding and decoding. 

            ImageReader reader = (ImageReader) readers.next();
            Object source = bis;
            ImageInputStream iis = ImageIO.createImageInputStream(source);
            reader.setInput(iis, true);
            ImageReadParam param = reader.getDefaultReadParam();

            Image image1 = reader.read(0, param);
            //got an image file

            BufferedImage bufferedImage = new BufferedImage(image1.getWidth(null), image1.getHeight(null), BufferedImage.TYPE_INT_RGB);
            //bufferedImage is the RenderedImage to be written

            Graphics2D g2 = bufferedImage.createGraphics();
            g2.drawImage(image1, null, null);

            File imageFile1 = new File("C:\\Users\\user\\Desktop\\encryption\\decompress.jpg");
            ImageIO.write(bufferedImage, "jpg", imageFile1);
            System.out.println(imageFile1.getPath());
        } catch (IOException ex) {
            Logger.getLogger(ImageEncode.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public static void main(String[] args) throws Exception {
        new ImageEncode();

    }//main(-)

    public static String imageToBase64String(File imageFile) throws Exception {

        String image = null;
        BufferedImage buffImage = ImageIO.read(imageFile);

        if (buffImage != null) {
            java.io.ByteArrayOutputStream os = new java.io.ByteArrayOutputStream();
            ImageIO.write(buffImage, "jpg", os);
            byte[] data = os.toByteArray();
            image = MyBase64.encode(data);

        }
        return image;
    }

    public static byte[] compress(String str) throws Exception {
        System.out.println("String length : " + str.length());
        ByteArrayOutputStream obj = new ByteArrayOutputStream();
        GZIPOutputStream gzip = new GZIPOutputStream(obj);
        gzip.write(str.getBytes("UTF-8"));
        gzip.close();
        return obj.toByteArray();
    }

    public static String decompress(byte[] bytes) throws Exception {
        GZIPInputStream gis = new GZIPInputStream(new ByteArrayInputStream(bytes));
        BufferedReader bf = new BufferedReader(new InputStreamReader(gis, "UTF-8"));
        String outStr = "";
        String line;
        while ((line = bf.readLine()) != null) {
            outStr += line;
        }
        System.out.println("Output String lenght : " + outStr.length());
        return outStr;
    }
}//class

公共类ImageEncode{
public ImageEncode（）引发异常{
试一试{
File imageFile=新文件（“C:\\Users\\user\\Desktop\\encryption\\original.jpg”）；
字符串img=ImageToBase64字符串（imageFile）；
System.out.println（“转换字符串”+img）；
//压缩
字节[]压缩=压缩（img）；
字符串dd=MyBase64.encode（压缩）；
ByteArrayInputStream bis1=新的ByteArrayInputStream（压缩）；
迭代器readers1=ImageIO.getImageReadersByFormatName（“jpg”）；
//ImageIO是一个包含用于定位ImageReaders的静态方法的类
//和图像编写器，并执行简单的编码和解码。
ImageReader reader1=（ImageReader）reader1.next（）；
objectsource1=bis1；
ImageInputStream iis1=ImageIO.CreateMageInputStream（source1）；
reader1.setInput（iis1，真）；
ImageReadParam param1=reader1.getDefaultReadParam（）；
Image image11=reader1.read（0，参数1）；
//有图像文件吗
BuffereImage BuffereImage 1=新的BuffereImage（image11.getWidth（null）、image11.getHeight（null）、BuffereImage.TYPE_INT_RGB）；
//BuffereImage是要写入的渲染图像
Graphics2D g21=bufferedImage1.createGraphics（）；
g21.drawImage（image11，null，null）；
File imageFile11=新文件（“C:\\Users\\user\\Desktop\\encryption\\compress.jpg”）；
写入（bufferedImage1，“jpg”，imageFile11）；
//减压
字符串dcr=解压缩（压缩）；
系统输出打印项次（“转换的字符串1”+dcr）；
字节[]d=MyBase64.解码（dcr）；
ByteArrayInputStream bis=新的ByteArrayInputStream（d）；
迭代器阅读器=ImageIO.getImageReadersByFormatName（“jpg”）；
//ImageIO是一个包含用于定位ImageReaders的静态方法的类
//和图像编写器，并执行简单的编码和解码。
ImageReader=（ImageReader）readers.next（）；
对象源=bis；
ImageInputStream iis=ImageIO.createImageInputStream（源）；
reader.setInput（iis，true）；
ImageReadParam param=reader.getDefaultReadParam（）；
Image image1=reader.read（0，参数）；
//有图像文件吗
BuffereImage BuffereImage=新的BuffereImage（image1.getWidth（null）、image1.getHeight（null）、BuffereImage.TYPE_INT_RGB）；
//BuffereImage是要写入的渲染图像
Graphics2D g2=buffereImage.createGraphics（）；
g2.drawImage（image1，null，null）；
File imageFile1=新文件（“C:\\Users\\user\\Desktop\\encryption\\decompress.jpg”）；
写入（bufferedImage，“jpg”，imageFile1）；
System.out.println（imageFile1.getPath（））；
}捕获（IOEX异常）{
Logger.getLogger（ImageEncode.class.getName（））.log（Level.SEVERE，null，ex）；
}
}
公共静态void main（字符串[]args）引发异常{
新的ImageEncode（）；
}//主（-）
公共静态字符串imageToBase64String（文件imageFile）引发异常{
字符串image=null；
BuffereImage buffImage=ImageIO.read（imageFile）；
if（buffImage！=null）{
java.io.ByteArrayOutputStream os=new java.io.ByteArrayOutputStream（）；
写入（buffImage，“jpg”，os）；
字节[]数据=os.toByteArray（）；
image=MyBase64.encode（数据）；
}
返回图像；
}
公共静态字节[]压缩（字符串str）引发异常{
System.out.println（“字符串长度：+str.length（））；
ByteArrayOutputStream obj=新建ByteArrayOutputStream（）；
GZIPOutputStream gzip=新的GZIPOutputStream（obj）；
写入（str.getBytes（“UTF-8”）；
gzip.close（）；
返回obj.toByteArray（）；
}
公共静态字符串解压缩（字节[]字节）引发异常{
GZIPInputStream gis=新的GZIPInputStream（新的ByteArrayInputStream（字节））；
BufferedReader bf=新的BufferedReader（新的InputStreamReader（gis，“UTF-8”））；
字符串outsr=“”；
弦线；
而（（line=bf.readLine（））！=null）{
outStr+=线路；
}
System.out.println（“输出字符串长度：+outtr.length（））；
回报率；
}
}//阶级

MyBase64.java

public class MyBase64 {

private final static char[] ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".toCharArray();
private static int[]  toInt   = new int[128];

static {
 for(int i=0; i< ALPHABET.length; i++){
 toInt[ALPHABET[i]]= i;
 }
}

public static String encode(byte[] buf){
  int size = buf.length;
  char[] ar = new char[((size + 2) / 3) * 4];
  int a = 0;
  int i=0;
       while(i < size){
           byte b0 = buf[i++];
           byte b1 = (i < size) ? buf[i++] : 0;
           byte b2 = (i < size) ? buf[i++] : 0;

           int mask = 0x3F;
           ar[a++] = ALPHABET[(b0 >> 2) & mask];
           ar[a++] = ALPHABET[((b0 << 4) | ((b1 & 0xFF) >> 4)) & mask];
           ar[a++] = ALPHABET[((b1 << 2) | ((b2 & 0xFF) >> 6)) & mask];
           ar[a++] = ALPHABET[b2 & mask];
       }//while

       switch(size % 3){
          case 1: ar[--a]  = '=';
          case 2: ar[--a]  = '=';
       }//switch
    return new String(ar);
 }

/**
 * Translates the specified Base64 string into a byte array.
 *
 * @param s the Base64 string (not null)
 * @return the byte array (not null)
 */
 public static byte[] decode(String s){
 int delta = s.endsWith( "==" ) ? 2 : s.endsWith( "=" ) ? 1 : 0;
 byte[] buffer = new byte[s.length()*3/4 - delta];
 int mask = 0xFF;
 int index = 0;

 for(int i=0; i< s.length(); i+=4){
      int c0 = toInt[s.charAt( i )];
      int c1 = toInt[s.charAt( i + 1)];
      buffer[index++]= (byte)(((c0 << 2) | (c1 >> 4)) & mask);

 if(index >= buffer.length){
   return buffer;
 }//if

   int c2 = toInt[s.charAt( i + 2)];
   buffer[index++]= (byte)(((c1 << 4) | (c2 >> 2)) & mask);

 if(index >= buffer.length){
     return buffer;
 }//if

   int c3 = toInt[s.charAt( i + 3 )];
   buffer[index++]= (byte)(((c2 << 6) | c3) & mask);
   }//for
   return buffer;
  }

}

公共类MyBase64{
私有最终静态字符[]ALPHABET=“abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz012456789+/”。tocharray（）；
私有静态int[]toInt=new int[128]；
静止的{
for（int i=0；i>2）和掩码]；
ar[a++]=字母表[（b0>4））&掩码]；
ar[a++]=字母表[（b1>6））&掩码]；
ar[a++]=字母表[b2和掩码]；
}//当
交换机（大小%3）{
案例1:ar[--a]='='；
案例2:ar[--a]='='；
}//开关
返回新字符串（ar）；
}
/**
*将指定的Base64字符串转换为字节数组。
*
*@param s Base64字符串（非空）
*@返回字节
SEVERE: null
javax.imageio.IIOException: Not a JPEG file: starts with 0x1f 0x8b
    at com.sun.imageio.plugins.jpeg.JPEGImageReader.readImageHeader(Native Method)
    at com.sun.imageio.plugins.jpeg.JPEGImageReader.readNativeHeader(JPEGImageReader.java:604)
    at com.sun.imageio.plugins.jpeg.JPEGImageReader.checkTablesOnly(JPEGImageReader.java:342)
    at com.sun.imageio.plugins.jpeg.JPEGImageReader.gotoImage(JPEGImageReader.java:476)
    at com.sun.imageio.plugins.jpeg.JPEGImageReader.readHeader(JPEGImageReader.java:597)
    at com.sun.imageio.plugins.jpeg.JPEGImageReader.readInternal(JPEGImageReader.java:1054)
    at com.sun.imageio.plugins.jpeg.JPEGImageReader.read(JPEGImageReader.java:1034)
    at Process.ImageEncode.<init>(ImageEncode.java:54)
    at Process.ImageEncode.main(ImageEncode.java:102)