Convertir InputStream de tableau d'octets en Java

Vous pouvez utiliser Apache Commons IO pour gérer ce type de tâches.

La IOUtils type possède une méthode statique pour lire un InputStream et retourner un byte[].

InputStream is;
byte[] bytes = IOUtils.toByteArray(is);

En interne, ce qui crée un ByteArrayOutputStream et copie les octets à la sortie, puis appelle toByteArray(). Il gère de gros fichiers par copier les octets dans des blocs de 4KiB.

Enfin, après une vingtaine d'années, il y a une solution simple, sans la nécessité pour une 3ème partie de la bibliothèque, grâce à Java 9:

InputStream is;
…
byte[] array = is.readAllBytes();

Note également la commodité des méthodes readNBytes(byte[] b, int off, int len) et transferTo(OutputStream) abordant les besoins récurrents.

Si vous arrive d'utiliser google goyave, ça va être aussi simple que :

byte[] bytes = ByteStreams.toByteArray(inputStream);

public static byte[] getBytesFromInputStream(InputStream is) throws IOException {
    ByteArrayOutputStream os = new ByteArrayOutputStream(); 
    byte[] buffer = new byte[0xFFFF];
    for (int len = is.read(buffer); len != -1; len = is.read(buffer)) { 
        os.write(buffer, 0, len);
    }
    return os.toByteArray();
}

Sûr solution (avec une capacité d' close flux correctement):

• Java 9+ version:

  final byte[] bytes;
  try (inputStream) {
      bytes = inputStream.readAllBytes();
  }

• Java 8 version:

  public static byte[] readAllBytes(InputStream inputStream) throws IOException {
      final int bufLen = 4 * 0x400; //4KB
      byte[] buf = new byte[bufLen];
      int readLen;
      IOException exception = null;
  
      try {
          try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
              while ((readLen = inputStream.read(buf, 0, bufLen)) != -1)
                  outputStream.write(buf, 0, readLen);
  
              return outputStream.toByteArray();
          }
      } catch (IOException e) {
          exception = e;
          throw e;
      } finally {
          if (exception == null) inputStream.close();
          else try {
              inputStream.close();
          } catch (IOException e) {
              exception.addSuppressed(e);
          }
      }
  }

• Kotlin version (lorsque Java 9+ n'est pas accessible):

  @Throws(IOException::class)
  fun InputStream.readAllBytes(): ByteArray {
      val bufLen = 4 * 0x400 //4KB
      val buf = ByteArray(bufLen)
      var readLen: Int = 0
  
      ByteArrayOutputStream().use { o ->
          this.use { i ->
              while (i.read(buf, 0, bufLen).also { readLen = it } != -1)
                  o.write(buf, 0, readLen)
          }
  
          return o.toByteArray()
      }
  }

  Pour éviter imbriquée use voir ici.

Au cas où quelqu'un est toujours à la recherche d'une solution sans une dépendance et Si vous avez un fichier.

1) DataInputStream

 byte[] data = new byte[(int) file.length()];
 DataInputStream dis = new DataInputStream(new FileInputStream(file));
 dis.readFully(data);
 dis.close();

2) ByteArrayOutputStream

 InputStream is = new FileInputStream(file);
 ByteArrayOutputStream buffer = new ByteArrayOutputStream();
 int nRead;
 byte[] data = new byte[(int) file.length()];
 while ((nRead = is.read(data, 0, data.length)) != -1) {
     buffer.write(data, 0, nRead);
 }

3) RandomAccessFile

 RandomAccessFile raf = new RandomAccessFile(file, "r");
 byte[] data = new byte[(int) raf.length()];
 raf.readFully(data);

@Adamski: Vous pouvez éviter tampon entièrement.

Code copié à partir de http://www.exampledepot.com/egs/java.io/File2ByteArray.html (Oui, c'est très détaillé, mais les besoins de la moitié de la taille de la mémoire comme de l'autre solution.)

//Returns the contents of the file in a byte array.
public static byte[] getBytesFromFile(File file) throws IOException {
    InputStream is = new FileInputStream(file);

    //Get the size of the file
    long length = file.length();

    //You cannot create an array using a long type.
    //It needs to be an int type.
    //Before converting to an int type, check
    //to ensure that file is not larger than Integer.MAX_VALUE.
    if (length > Integer.MAX_VALUE) {
        //File is too large
    }

    //Create the byte array to hold the data
    byte[] bytes = new byte[(int)length];

    //Read in the bytes
    int offset = 0;
    int numRead = 0;
    while (offset < bytes.length
           && (numRead=is.read(bytes, offset, bytes.length-offset)) >= 0) {
        offset += numRead;
    }

    //Ensure all the bytes have been read in
    if (offset < bytes.length) {
        throw new IOException("Could not completely read file "+file.getName());
    }

    //Close the input stream and return bytes
    is.close();
    return bytes;
}

Java 9 vous donnera enfin une belle méthode:

InputStream in = ...;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
in.transferTo( bos );
byte[] bytes = bos.toByteArray();

Java 8 (grâce à BufferedReader et Adam Bien)

private static byte[] readFully(InputStream input) throws IOException {
    try (BufferedReader buffer = new BufferedReader(new InputStreamReader(input))) {
        return buffer.lines().collect(Collectors.joining("\n")).getBytes(<charset_can_be_specified>);
    }
}

Note que cette solution lingettes retour chariot ('\r') et peut être inapproprié.

Voir le InputStream.available() documentation:

Il est particulièrement important de réaliser que vous ne devez pas utiliser ce
méthode à la taille d'un conteneur et d'assumer que vous pouvez lire l'intégralité
des flux sans avoir besoin de redimensionner le conteneur. Ces appelants
devrait probablement écrire tout ce qu'ils lisent à une ByteArrayOutputStream
et convertir un tableau d'octets. Alternativement, si vous êtes en train de lire
à partir d'un fichier, Fichier.longueur retourne la longueur de la file
(mais en supposant que la longueur du fichier ne peut pas changer peut-être incorrect
la lecture d'un fichier est intrinsèquement racé).

Vous êtes en train de faire une copie supplémentaire si vous utilisez ByteArrayOutputStream. Si vous connaissez la longueur du cours d'eau avant de commencer à le lire (par exemple, l'InputStream est en fait un FileInputStream, et vous pouvez les appeler de fichier.longueur() sur le fichier, ou le InputStream est un zipfile entrée InputStream, et vous pouvez les appeler zipEntry.longueur()), alors il est de loin préférable d'écrire directement dans le byte[] tableau -- il utilise la moitié de la mémoire, et permet de gagner du temps.

//Read the file contents into a byte[] array
byte[] buf = new byte[inputStreamLength];
int bytesRead = Math.max(0, inputStream.read(buf));

//If needed: for safety, truncate the array if the file may somehow get
//truncated during the read operation
byte[] contents = bytesRead == inputStreamLength ? buf
                  : Arrays.copyOf(buf, bytesRead);

N. B. la dernière ligne ci-dessus traite de fichiers tronqués alors que le flux est en cours de lecture, si vous avez besoin pour gérer cette possibilité, mais si le fichier est plus alors que le flux est en cours de lecture, le contenu dans le byte[] tableau ne sera pas allongée pour inclure le nouveau contenu du fichier, le tableau sera simplement tronqué à l'ancienne longueur inputStreamLength.

C'est mon copier-coller de la version:

@SuppressWarnings("empty-statement")
public static byte[] inputStreamToByte(InputStream is) throws IOException {
    if (is == null) {
        return null;
    }
    //Define a size if you have an idea of it.
    ByteArrayOutputStream r = new ByteArrayOutputStream(2048);
    byte[] read = new byte[512]; //Your buffer size.
    for (int i; -1 != (i = is.read(read)); r.write(read, 0, i));
    is.close();
    return r.toByteArray();
}

De l'envelopper dans un DataInputStream si c'est hors de la table pour une raison quelconque, il suffit d'utiliser lire de marteau jusqu'à ce qu'il vous donne un -1 ou la totalité du bloc que vous avez demandé.

public int readFully(InputStream in, byte[] data) throws IOException {
    int offset = 0;
    int bytesRead;
    boolean read = false;
    while ((bytesRead = in.read(data, offset, data.length - offset)) != -1) {
        read = true;
        offset += bytesRead;
        if (offset >= data.length) {
            break;
        }
    }
    return (read) ? offset : -1;
}

Nous voyons un peu de retard pour quelques AWS transaction, lors de la conversion S3 objet ByteArray.

Remarque: S3 Objet d'un document PDF (taille max est de 3 mo).

Nous sommes à l'aide de l'option #1 (org.apache.commons.io.IOUtils) pour convertir le S3 objet ByteArray. Nous avons remarqué S3 fournir les inbuild IOUtils méthode pour convertir le S3 objet ByteArray, nous vous demandons de confirmer quel est le meilleur moyen de convertir le S3 objet ByteArray pour éviter le retard.

Option #1:

import org.apache.commons.io.IOUtils;
is = s3object.getObjectContent();
content =IOUtils.toByteArray(is);

Option #2:

import com.amazonaws.util.IOUtils;
is = s3object.getObjectContent();
content =IOUtils.toByteArray(is);

Aussi laissez-moi savoir si nous avons de meilleur moyen pour convertir les s3 objet bytearray

/*InputStream class_InputStream = null;
I am reading class from DB 
class_InputStream = rs.getBinaryStream(1);
Your Input stream could be from any source
*/
int thisLine;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
while ((thisLine = class_InputStream.read()) != -1) {
bos.write(thisLine);
}
bos.flush();
byte [] yourBytes = bos.toByteArray();
/*Don't forget in the finally block to close ByteArrayOutputStream & InputStream
In my case the IS is from resultset so just closing the rs will do it*/
if (bos != null){
bos.close();
}

Ci-Dessous Les Codes

public static byte[] serializeObj(Object obj) throws IOException {
ByteArrayOutputStream baOStream = new ByteArrayOutputStream();
ObjectOutputStream objOStream = new ObjectOutputStream(baOStream);
objOStream.writeObject(obj); 
objOStream.flush();
objOStream.close();
return baOStream.toByteArray(); 
} 

OU

BufferedImage img = ...
ByteArrayOutputStream baos = new ByteArrayOutputStream(1000);
ImageIO.write(img, "jpeg", baos);
baos.flush();
byte[] result = baos.toByteArray();
baos.close();