我有这个类来编码和解码文件。当我用 .txt 文件运行类时，结果是成功的。但是当我用 .jpg 或 .doc 运行代码时，我无法打开文件或者它不等于原始文件。我不知道为什么会这样。我修改了这个类 http://myjeeva.com/convert-image-to-string-and-string-to-image-in-java.html .但我想改变这一行

byte imageData[] = new byte[(int) file.length()];

对于

byte example[] = new byte[1024];

并根据需要多次读取文件。谢谢。

import java.io.*;
import java.util.*;

  public class Encode {

Input = 输入文件根 - Output = 输出文件根 - imageDataString = String encoded

  String input;
  String output;
  String imageDataString;


  public void setFileInput(String input){
    this.input=input;
  }

  public void setFileOutput(String output){
    this.output=output;
  }

  public String getFileInput(){
    return input;
  }

  public String getFileOutput(){
    return output;
  }

  public String getEncodeString(){
    return  imageDataString;
  }

  public String processCode(){
    StringBuilder sb= new StringBuilder();

    try{
        File fileInput= new File( getFileInput() );
        FileInputStream imageInFile = new FileInputStream(fileInput);

我在示例中看到人们创建了一个与文件长度相同的 byte[]。我不想要这个，因为我不知道文件的长度。

        byte buff[] = new byte[1024];

        int r = 0;

        while ( ( r = imageInFile.read( buff)) > 0 ) {

          String imageData = encodeImage(buff);

          sb.append( imageData);

          if ( imageInFile.available() <= 0 ) {
            break;
          }
        }



       } catch (FileNotFoundException e) {
        System.out.println("File not found" + e);
      } catch (IOException ioe) {
        System.out.println("Exception while reading the file " + ioe);

    } 

        imageDataString = sb.toString();

       return imageDataString;
}  


  public  void processDecode(String str) throws IOException{

      byte[] imageByteArray = decodeImage(str);
      File fileOutput= new File( getFileOutput());
      FileOutputStream imageOutFile = new FileOutputStream( fileOutput);

      imageOutFile.write(imageByteArray);
      imageOutFile.close();

}

 public static String encodeImage(byte[] imageByteArray) {

      return  Base64.getEncoder().withoutPadding().encodeToString( imageByteArray);

    }

    public static byte[] decodeImage(String imageDataString) {
      return  Base64.getDecoder().decode(  imageDataString);  

    }


  public static void main(String[] args) throws IOException {

    Encode a = new Encode();

    a.setFileInput( "C://Users//xxx//Desktop//original.doc");
    a.setFileOutput("C://Users//xxx//Desktop//original-copied.doc");

    a.processCode( );

    a.processDecode( a.getEncodeString());

    System.out.println("C O P I E D");
  }
}

我试着改变

String imageData = encodeImage(buff);

对于

String imageData = encodeImage(buff,r);

和方法encodeImage

public static String encodeImage(byte[] imageByteArray, int r) {

     byte[] aux = new byte[r];

     for ( int i = 0; i < aux.length; i++) {
       aux[i] = imageByteArray[i];

       if ( aux[i] <= 0 ) {
         break;
       }
     }
return  Base64.getDecoder().decode(  aux);
}

但是我有错误:

Exception in thread "main" java.lang.IllegalArgumentException: Last unit does not have enough valid bits   

最佳答案

你的程序有两个问题。

第一个，正如@Joop Eggen 所提到的，是您没有正确处理您的输入。

事实上，Java 并没有向您保证即使在文件的中间，您也会读取整个 1024 字节。它可以只读取 50 个字节，并告诉您它读取了 50 个字节，然后下一次它会再读取 50 个字节。

假设您在上一轮中读取了 1024 个字节。现在，在本轮中，您只读取了 50 个。您的字节数组现在包含 50 个新字节，其余是上次读取的旧字节!

因此，您始终需要将复制的确切字节数复制到一个新数组，并将其传递给您的编码函数。

因此，要解决此特定问题，您需要执行以下操作:

 while ( ( r = imageInFile.read( buff)) > 0 ) {

      byte[] realBuff = Arrays.copyOf( buff, r );

      String imageData = encodeImage(realBuff);

      ...
 }

然而，这不是这里唯一的问题。您真正的问题在于 Base64 编码本身。

Base64 所做的是获取您的字节，将它们分成 6 位 block ，然后将这些 block 中的每一个视为 N 0 到 63 之间的数字。然后它从其字符表中获取第 N 个字符，以表示该 block .

但这意味着它不能只编码一个字节或两个字节，因为一个字节包含 8 位，这意味着一个 6 位 block 和 2 个剩余位。两个字节有 16 位。那是 2 个 6 位 block 和 4 个剩余位。

为了解决这个问题，Base64总是对3个连续的字节进行编码。如果输入不能除以三，它会添加额外的零位。

这是一个演示问题的小程序:

package testing;

import java.util.Base64;

public class SimpleTest {

    public static void main(String[] args) {

        // An array containing six bytes to encode and decode.
        byte[] fullArray = { 0b01010101, (byte) 0b11110000, (byte)0b10101010, 0b00001111, (byte)0b11001100, 0b00110011 };

        // The same array broken into three chunks of two bytes.

        byte[][] threeTwoByteArrays = {
            {       0b01010101, (byte) 0b11110000 },
            { (byte)0b10101010,        0b00001111 },
            { (byte)0b11001100,        0b00110011 }
        };
        Base64.Encoder encoder = Base64.getEncoder().withoutPadding();

        // Encode the full array

        String encodedFullArray = encoder.encodeToString(fullArray);

        // Encode the three chunks consecutively 

        StringBuilder encodedStringBuilder = new StringBuilder();
        for ( byte [] twoByteArray : threeTwoByteArrays ) {
            encodedStringBuilder.append(encoder.encodeToString(twoByteArray));
        }
        String encodedInChunks = encodedStringBuilder.toString();

        System.out.println("Encoded full array: " + encodedFullArray);
        System.out.println("Encoded in chunks of two bytes: " + encodedInChunks);

        // Now  decode the two resulting strings

        Base64.Decoder decoder = Base64.getDecoder();

        byte[] decodedFromFull = decoder.decode(encodedFullArray);   
        System.out.println("Byte array decoded from full: " + byteArrayBinaryString(decodedFromFull));

        byte[] decodedFromChunked = decoder.decode(encodedInChunks);
        System.out.println("Byte array decoded from chunks: " + byteArrayBinaryString(decodedFromChunked));
    }

    /**
     * Convert a byte array to a string representation in binary
     */
    public static String byteArrayBinaryString( byte[] bytes ) {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for ( byte b : bytes ) {
            sb.append(Integer.toBinaryString(Byte.toUnsignedInt(b))).append(',');
        }
        if ( sb.length() > 1) {
            sb.setCharAt(sb.length() - 1, ']');
        } else {
            sb.append(']');
        }
        return sb.toString();
    }
}

所以，假设我的 6 字节数组是您的图像文件。并想象您的缓冲区不是每次读取 1024 个字节而是 2 个字节。这将是编码的输出:

Encoded full array: VfCqD8wz
Encoded in chunks of two bytes: VfAqg8zDM

如您所见，完整数组的编码为我们提供了 8 个字符。每组三个字节被转换成四个 6 位的 block ，这些 block 又被转换成四个字符。

但是三个双字节数组的编码给了你一个 9 个字符的字符串。这是一个完全不同的字符串!通过用零填充，将每组两个字节扩展为三个 6 位 block 。并且由于您要求不填充，它只产生 3 个字符，没有额外的 = 通常标记字节数不能被 3 整除。

解码 8 字符正确编码字符串的程序部分的输出很好:

Byte array decoded from full: [1010101,11110000,10101010,1111,11001100,110011]

但是尝试解码 9 个字符的错误编码字符串的结果是:

Exception in thread "main" java.lang.IllegalArgumentException: Last unit does not have enough valid bits
    at java.util.Base64$Decoder.decode0(Base64.java:734)
    at java.util.Base64$Decoder.decode(Base64.java:526)
    at java.util.Base64$Decoder.decode(Base64.java:549)
    at testing.SimpleTest.main(SimpleTest.java:34)

不好!一个好的 base64 字符串应该总是 4 个字符的倍数，而我们只有 9 个。

由于您选择的缓冲区大小为 1024，它不是 3 的倍数，所以该问题将会发生。您需要每次对 3 个字节的倍数进行编码才能生成正确的字符串。所以实际上，您需要创建一个大小为 3072 或类似大小的缓冲区。

但是由于第一个问题，在传递给编码器的内容时​​要非常小心。因为您总是会读取少于 3072 字节的情况。然后，如果这个数不能被三整除，也会出现同样的问题。

关于java - base64 java中的失败编码文件，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/31182657/