Java InputStream to Arte Array

Java InputStream to Byte Array et ByteBuffer

1. Vue d'ensemble

Dans ce rapide tutoriel, nous allons voir comment convertir unInputStream enbyte[] etByteBuffer - en utilisant d'abord Java brut, puis en utilisant Guava et Commons IO.

Cet article fait partie dethe “Java – Back to Basic” series ici par exemple.

Lectures complémentaires:

Introduction à Spring’s StreamUtils

Découvrez la classe StreamUtils de Spring.

Introduction à la sérialisation Java

Nous apprenons à sérialiser et à désérialiser des objets en Java.

Conversions de chaînes Java

Des exemples rapides et pratiques axés sur la conversion d'objets String en différents types de données en Java.

2. Convertir en tableau d'octets

Voyons comment obtenir un tableau d'octets à partir de flux d'entrée simples. L'aspect important d'un tableau d'octets est queit enables an indexed (fast) access to each 8-bit (a byte) value stored in memory. Par conséquent, vous pouvez manipuler ces octets pour contrôler chaque bit. Nous allons voir comment convertir un flux d'entrée simple en unbyte[] - d'abord en utilisant Java brut, puis en utilisantGuava etApache Commons IO.

2.1. Convertir à l'aide de Java brut

Commençons par une solution Java axée sur le traitement d'un flux de taille fixe:

@Test
public void givenUsingPlainJava_whenConvertingAnInputStreamToAByteArray_thenCorrect()
  throws IOException {
    InputStream initialStream = new ByteArrayInputStream(new byte[] { 0, 1, 2 });

    byte[] targetArray = new byte[initialStream.available()];
    initialStream.read(targetArray);
}

Dans le cas d'un flux mis en mémoire tampon - où nous avons affaire à un flux mis en mémoire tampon et ne connaissons pas la taille exacte des données sous-jacentes, nous devons rendre la mise en œuvre plus flexible:

@Test
public void
  givenUsingPlainJavaOnUnknownSizeStream_whenConvertingAnInputStreamToAByteArray_thenCorrect()
  throws IOException {
    InputStream is = new ByteArrayInputStream(new byte[] { 0, 1, 2 }); // not really unknown

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

    buffer.flush();
    byte[] byteArray = buffer.toByteArray();
}

2.2. Convertir à l'aide de la goyave

Examinons maintenant la solution simple basée sur Guava - en utilisant la classe utilitaire ByteStreams pratique:

@Test
public void givenUsingGuava_whenConvertingAnInputStreamToAByteArray_thenCorrect()
  throws IOException {
    InputStream initialStream = ByteSource.wrap(new byte[] { 0, 1, 2 }).openStream();

    byte[] targetArray = ByteStreams.toByteArray(initialStream);
}

2.3. Convertir à l'aide de Commons IO

Et enfin - une solution simple utilisant Apache Commons IO:

@Test
public void givenUsingCommonsIO_whenConvertingAnInputStreamToAByteArray_thenCorrect()
  throws IOException {
    ByteArrayInputStream initialStream = new ByteArrayInputStream(new byte[] { 0, 1, 2 });

    byte[] targetArray = IOUtils.toByteArray(initialStream);
}

La méthodeIOUtils.toByteArray() met l'entrée en mémoire tampon en interne, il y a doncno need to use a BufferedInputStream instance lorsque la mise en mémoire tampon est nécessaire.

3. Convertir enByteBuffer

Voyons maintenant comment obtenir unByteBuffer à partir d'unInputStream. C'estuseful whenever we need to do fast and direct low-level I/O operations in memory.

En utilisant la même approche que les sections ci-dessus, nous allons examiner comment convertir unInputStream en unByteBuffer - d'abord en utilisant Java brut, puis en utilisant Guava et Commons IO.

3.1. Convertir à l'aide de Java brut

Dans le cas d'un flux d'octets, nous connaissons la taille exacte des données sous-jacentes. Utilisons la méthodeByteArrayInputStream#available pour lire le flux d'octets dans unByteBuffer:

@Test
public void givenUsingCoreClasses_whenByteArrayInputStreamToAByteBuffer_thenLengthMustMatch()
  throws IOException {
    byte[] input = new byte[] { 0, 1, 2 };
    InputStream initialStream = new ByteArrayInputStream(input);
    ByteBuffer byteBuffer = ByteBuffer.allocate(3);
    while (initialStream.available() > 0) {
        byteBuffer.put((byte) initialStream.read());
    }

    assertEquals(byteBuffer.position(), input.length);
}

3.2. Convertir à l'aide de la goyave

Examinons maintenant une solution simple basée sur Guava - en utilisant la classe utilitaire pratiqueByteStreams:

@Test
public void givenUsingGuava__whenByteArrayInputStreamToAByteBuffer_thenLengthMustMatch()
  throws IOException {
    InputStream initialStream = ByteSource
      .wrap(new byte[] { 0, 1, 2 })
      .openStream();
    byte[] targetArray = ByteStreams.toByteArray(initialStream);
    ByteBuffer bufferByte = ByteBuffer.wrap(targetArray);
    while (bufferByte.hasRemaining()) {
        bufferByte.get();
    }

    assertEquals(bufferByte.position(), targetArray.length);
}

Ici, nous utilisons une boucle while avec la méthodehasRemaining pour montrer une manière différente de lire tous les octets dans lesByteBuffer. Sinon, l'assertion échouerait car la position d'index deByteBuffer sera nulle.

3.3. Convertir à l'aide de Commons IO

Et enfin - en utilisant Apache Commons IO et la classeIOUtils:

@Test
public void givenUsingCommonsIo_whenByteArrayInputStreamToAByteBuffer_thenLengthMustMatch()
  throws IOException {
    byte[] input = new byte[] { 0, 1, 2 };
    InputStream initialStream = new ByteArrayInputStream(input);
    ByteBuffer byteBuffer = ByteBuffer.allocate(3);
    ReadableByteChannel channel = newChannel(initialStream);
    IOUtils.readFully(channel, byteBuffer);

    assertEquals(byteBuffer.position(), input.length);
}

4. Conclusion

Cet article a illustré différentes façons de convertir un flux d'entrée brut en un tableau d'octets et unByteBuffer en utilisant Java, Guava et Apache Commons IO.

L'implémentation de tous ces exemples peut être trouvée dans nosGitHub project.

TOC