J'ai été surpris de constater aujourd'hui que je ne pouvais pas trouver de moyen simple d'écrire le contenu d'un InputStreaman OutputStreamen Java. De toute évidence, le code tampon d'octets n'est pas difficile à écrire, mais je soupçonne que je manque juste quelque chose qui me faciliterait la vie (et le code plus clair).

Donc, étant donné un InputStream inet un OutputStream out, existe-t-il un moyen plus simple d'écrire ce qui suit?

byte[] buffer = new byte[1024];
int len = in.read(buffer);
while (len != -1) {
    out.write(buffer, 0, len);
    len = in.read(buffer);
}

Java 9

Depuis Java 9, InputStreamfournit une méthode appelée transferToavec la signature suivante:

public long transferTo(OutputStream out) throws IOException

Comme les documents états, transferToseront:

Lit tous les octets de ce flux d'entrée et écrit les octets dans le flux de sortie donné dans l'ordre où ils sont lus. Au retour, ce flux d'entrée sera à la fin du flux. Cette méthode ne ferme ni l'un ni l'autre des flux.

Cette méthode peut bloquer indéfiniment la lecture du flux d'entrée ou l'écriture dans le flux de sortie. Le comportement dans le cas où le flux d'entrée et / ou de sortie est fermé de manière asynchrone, ou le thread interrompu pendant le transfert, est très spécifique au flux d'entrée et de sortie, et donc non spécifié

Donc, pour écrire le contenu d'un Java InputStreamdans un OutputStream, vous pouvez écrire:

input.transferTo(output);

Comme l'a mentionné WMR, org.apache.commons.io.IOUtilsApache a une méthode appelée copy(InputStream,OutputStream)qui fait exactement ce que vous recherchez.

Vous avez donc:

InputStream in;
OutputStream out;
IOUtils.copy(in,out);
in.close();
out.close();

... dans votre code.

Y a-t-il une raison que vous évitez IOUtils?

Si vous utilisez Java 7, Files (dans la bibliothèque standard) est la meilleure approche:

/* You can get Path from file also: file.toPath() */
Files.copy(InputStream in, Path target)
Files.copy(Path source, OutputStream out)

Edit: Bien sûr, c'est juste utile lorsque vous créez l'un des InputStream ou OutputStream à partir d'un fichier. Utilisez file.toPath()pour obtenir le chemin du fichier.

Pour écrire dans un fichier existant (par exemple celui créé avec File.createTempFile()), vous devrez passer l' REPLACE_EXISTINGoption de copie (sinon elle FileAlreadyExistsExceptionest levée):

Files.copy(in, target, StandardCopyOption.REPLACE_EXISTING)

Je pense que cela fonctionnera, mais assurez-vous de le tester ... "amélioration" mineure, mais cela pourrait être un peu coûteux en termes de lisibilité.

byte[] buffer = new byte[1024];
int len;
while ((len = in.read(buffer)) != -1) {
    out.write(buffer, 0, len);
}

Utilisation de la goyave ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Fonction simple

Si vous n'en avez besoin que pour écrire un InputStreamdans un, Filevous pouvez utiliser cette fonction simple:

private void copyInputStreamToFile( InputStream in, File file ) {
    try {
        OutputStream out = new FileOutputStream(file);
        byte[] buf = new byte[1024];
        int len;
        while((len=in.read(buf))>0){
            out.write(buf,0,len);
        }
        out.close();
        in.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Le JDKutilise le même code, il semble donc qu'il n'y a pas de moyen "plus facile" sans bibliothèques tierces maladroites (qui ne font probablement rien de différent de toute façon). Ce qui suit est directement copié de java.nio.file.Files.java:

// buffer size used for reading and writing
private static final int BUFFER_SIZE = 8192;

/**
  * Reads all bytes from an input stream and writes them to an output stream.
  */
private static long copy(InputStream source, OutputStream sink) throws IOException {
    long nread = 0L;
    byte[] buf = new byte[BUFFER_SIZE];
    int n;
    while ((n = source.read(buf)) > 0) {
        sink.write(buf, 0, n);
        nread += n;
    }
    return nread;
}

PipedInputStreamet PipedOutputStreamne doit être utilisé que lorsque vous avez plusieurs threads, comme indiqué par Javadoc .

Notez également que les flux d'entrée et les flux de sortie n'encapsulent aucune interruption de thread avec IOExceptions ... Donc, vous devriez envisager d'incorporer une politique d'interruption à votre code:

byte[] buffer = new byte[1024];
int len = in.read(buffer);
while (len != -1) {
    out.write(buffer, 0, len);
    len = in.read(buffer);
    if (Thread.interrupted()) {
        throw new InterruptedException();
    }
}

Ce serait un ajout utile si vous prévoyez d'utiliser cette API pour copier de gros volumes de données ou des données de flux qui restent bloqués pendant une durée intolérable.

Pour ceux qui utilisent Spring Framework, il existe une classe StreamUtils utile :

StreamUtils.copy(in, out);

Ce qui précède ne ferme pas les flux. Si vous souhaitez que les flux soient fermés après la copie, utilisez plutôt la classe FileCopyUtils :

FileCopyUtils.copy(in, out);

Il n'y a aucun moyen de le faire beaucoup plus facilement avec les méthodes JDK, mais comme Apocalisp l'a déjà noté, vous n'êtes pas le seul à avoir cette idée: vous pouvez utiliser des IOUtils de Jakarta Commons IO , il a aussi beaucoup d'autres choses utiles, que l'OMI devrait en fait faire partie du JDK ...

Utilisant Java7 et try-with-resources , est livré avec une version simplifiée et lisible.

try(InputStream inputStream = new FileInputStream("C:\\mov.mp4");
    OutputStream outputStream = new FileOutputStream("D:\\mov.mp4")) {

    byte[] buffer = new byte[10*1024];

    for (int length; (length = inputStream.read(buffer)) != -1; ) {
        outputStream.write(buffer, 0, length);
    }
} catch (FileNotFoundException exception) {
    exception.printStackTrace();
} catch (IOException ioException) {
    ioException.printStackTrace();
}

Voici comment je fais avec le plus simple pour la boucle.

private void copy(final InputStream in, final OutputStream out)
    throws IOException {
    final byte[] b = new byte[8192];
    for (int r; (r = in.read(b)) != -1;) {
        out.write(b, 0, r);
    }
}

Utilisez la classe Util de Commons Net:

import org.apache.commons.net.io.Util;
...
Util.copyStream(in, out);

Un extrait de mon humble avis plus minimal (qui étend également plus étroitement la variable de longueur):

byte[] buffer = new byte[2048];
for (int n = in.read(buffer); n >= 0; n = in.read(buffer))
    out.write(buffer, 0, n);

En remarque, je ne comprends pas pourquoi plus de gens n'utilisent pas de forboucle, optant plutôt pour un whileavec une expression assign-and-test qui est considérée par certains comme un style "pauvre".

Ceci est mon meilleur coup !!

Et ne l'utilisez pas inputStream.transferTo(...)car il est trop générique. Les performances de votre code seront meilleures si vous contrôlez votre mémoire tampon.

public static void transfer(InputStream in, OutputStream out, int buffer) throws IOException {
    byte[] read = new byte[buffer]; // Your buffer size.
    while (0 < (buffer = in.read(read)))
        out.write(read, 0, buffer);
}

Je l'utilise avec cette méthode (évolutive) quand je connais à l'avance la taille du flux.

public static void transfer(int size, InputStream in, OutputStream out) throws IOException {
    transfer(in, out,
            size > 0xFFFF ? 0xFFFF // 16bits 65,536
                    : size > 0xFFF ? 0xFFF// 12bits 4096
                            : size < 0xFF ? 0xFF // 8bits 256
                                    : size
    );
}

Je pense qu'il vaut mieux utiliser un grand tampon, car la plupart des fichiers sont supérieurs à 1024 octets. Il est également recommandé de vérifier que le nombre d'octets de lecture est positif.

byte[] buffer = new byte[4096];
int n;
while ((n = in.read(buffer)) > 0) {
    out.write(buffer, 0, n);
}
out.close();

J'utilise BufferedInputStreamet BufferedOutputStreampour supprimer la sémantique de mise en mémoire tampon du code

try (OutputStream out = new BufferedOutputStream(...);
     InputStream in   = new BufferedInputStream(...))) {
  int ch;
  while ((ch = in.read()) != -1) {
    out.write(ch);
  }
}

PipedInputStream et PipedOutputStream peuvent être d'une certaine utilité, car vous pouvez vous connecter l'un à l'autre.

Un autre candidat possible sont les utilitaires d'E / S Guava:

http://code.google.com/p/guava-libraries/wiki/IOExplained

J'ai pensé les utiliser car Guava est déjà extrêmement utile dans mon projet, plutôt que d'ajouter une autre bibliothèque pour une fonction.

Pas très lisible, mais efficace, sans dépendances et fonctionne avec n'importe quelle version java

byte[] buffer = new byte[1024];
for (int n; (n = inputStream.read(buffer)) != -1; outputStream.write(buffer, 0, n));

public static boolean copyFile(InputStream inputStream, OutputStream out) {
    byte buf[] = new byte[1024];
    int len;
    long startTime=System.currentTimeMillis();

    try {
        while ((len = inputStream.read(buf)) != -1) {
            out.write(buf, 0, len);
        }

        long endTime=System.currentTimeMillis()-startTime;
        Log.v("","Time taken to transfer all bytes is : "+endTime);
        out.close();
        inputStream.close();

    } catch (IOException e) {

        return false;
    }
    return true;
}

Essayez Cactoos :

new LengthOf(new TeeInput(input, output)).value();

Plus de détails ici: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

vous pouvez utiliser cette méthode

public static void copyStream(InputStream is, OutputStream os)
 {
     final int buffer_size=1024;
     try
     {
         byte[] bytes=new byte[buffer_size];
         for(;;)
         {
           int count=is.read(bytes, 0, buffer_size);
           if(count==-1)
               break;
           os.write(bytes, 0, count);
         }
     }
     catch(Exception ex){}
 }