Moyen facile d'écrire du contenu d'une application Java InputStream à un OutputStream

J'ai été surpris de constater aujourd'hui que je ne pouvais pas trouver quelque moyen simple d'écrire le contenu d'un InputStream à un OutputStream en Java. Évidemment, le tampon d'octets de code n'est pas difficile à écrire, mais je pense que je suis juste en manque de quelque chose qui allait me rendre la vie plus facile (et le code plus clair).

Donc, étant donné un InputStream in et un OutputStream out, est-il un moyen plus simple d'écrire la suite?

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

Vous avez mentionné dans un commentaire que c'est pour une application mobile. Il est natif d'Android? Si oui, laissez-moi savoir et je vais poster une autre réponse (il peut être fait en une seule ligne de code sur Android).

InformationsquelleAutor Matt Sheppard | 2008-09-04

io java stream

162

Java 9

Depuis Java 9, InputStream fournit une méthode appelée transferTo avec la signature suivante:
```
public long transferTo(OutputStream out) throws IOException
```
Comme le la documentation unis, transferTo sera:

Lit tous les octets à partir de ce flux d'entrée et écrit les octets à la
compte tenu de flux de sortie dans l'ordre dans lequel ils sont lus. Sur le retour, cette
flux d'entrée sera à la fin du flux. Cette méthode ne permet pas de fermer
un ou l'autre volet.

Cette méthode peut bloquer indéfiniment la lecture à partir de la
flux d'entrée ou écriture sur le flux de sortie. Le comportement de la
cas où l'entrée et/ou sortie de flux de manière asynchrone fermé, ou
le fil interrompu pendant le transfert, est très d'entrée et de sortie
flux spécifiques, et ne sont donc pas spécifiées

Donc dans l'ordre pour écrire du contenu d'une application Java InputStream à un OutputStream, vous pouvez écrire:
```
input.transferTo(output);
```
- Vous devriez préférerFiles.copy autant que possible. Il est mis en œuvre dans le code natif et peut donc être plus rapide. transferTo devrait être utilisé seulement si les deux flux ne sont pas FileInputStream/FileOutputStream.
InformationsquelleAutor Ali Dehghani
393

Comme WMR mentionné, org.apache.commons.io.IOUtils de Apache a une méthode appelée copier(InputStream,OutputStream) qui fait exactement ce que vous cherchez.

Donc, vous avez:
```
InputStream in;
OutputStream out;
IOUtils.copy(in,out);
in.close();
out.close();
```
...dans votre code.

Est-il une raison pour laquelle vous êtes en évitant IOUtils?
- Je suis de l'éviter pour cette application mobile, je suis en train de construire la cause qu'il avait quintuple de la taille de l'app pour enregistrer un maigre 5 lignes de code.
- c'est peut-être intéressant de mentionner que in et out doit être fermé à la fin du code dans un bloc finally
- Ou à l'aide d'un essayez-le avec les ressources de bloc.
- Ou vous pouvez simplement écrire votre propre copie(in, out) wrapper ... (en beaucoup moins de temps faut pour ...)
- Si vous utilisez déjà la Goyave bibliothèque, Andrejs a recommandé la ByteStreams de classe ci-dessous. Semblable à ce que IOUtils n', mais évite l'ajout Commons IO à votre projet.
- Code ci-dessus avec IOUtils, va charger tout hors de flux en mémoire, puis de commencer à écrire à l'extérieur. Cette opération de mémoire l'habitude de causer problème si grands courants ?
- Avez-vous une référence pour cette demande? Quand je regarde le code source, je vois à peu près la même copie de la boucle, comme illustré par les OP et les réponses.
- Vous pouvez utiliser Maven Ombre la bande inutiles classes à partir de la dernière .jar, ce qui entraîne qu'une augmentation modeste dans le fichier jar taille
- Une sorte d'évidence, mais si la classe ne pas avoir trop de dépendances, vous pouvez aussi tout simplement copier le code source pour les libéraux de licences (comme ceux utilisés pour les deux Goyave et Apache). D'abord lire le contrat de licence si (avertissement, IANAL, etc.).
- La taille de l'application peuvent être gardés sous contrôle si proguard est utilisé.
- Si vous utilisez un gestionnaire de dépendance, comme Maven, et vous êtes en évitant IOUtils et de Goyave pour des raisons de taille, vous pouvez jeter un oeil à votre dépendance à la hiérarchie. Peut-être que l'un de vos dépendances transitivement comprend l'un de ces, sans préavis, ils sont très célèbres, après tout. Si c'est le cas, vous pourriez aussi bien utiliser vous-même , vous êtes, y compris de toute façon.
InformationsquelleAutor Mikezx6r
323

Si vous êtes à l'aide de Java 7, Fichiers (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 un de InputStream ou OutputStream à partir d'un fichier. Utilisation file.toPath() pour obtenir de chemin d'accès de fichier.

Pour écrire dans un fichier existant (par exemple, l'un créé avec File.createTempFile()), vous aurez besoin de passer le REPLACE_EXISTING option de copie (sinon FileAlreadyExistsException est jeté):
```
Files.copy(in, target, StandardCopyOption.REPLACE_EXISTING)
```
- Je ne pense pas que cela résout le problème depuis une extrémité est du chemin. Alors que vous pouvez obtenir un chemin d'accès pour un fichier, pour autant que je suis conscient que vous ne pouvez pas en obtenir un pour un médicament générique de flux (par exemple, l'un sur le réseau).
- +1 même avéré utile dans mon cas, comme j'ai un fichier réel sur le côté de sortie!
- Pour autant que je suis concerné, te première méthode que vous dites n'est pas disponible avec cette signature. Vous devez ajouter le CopyOptions paramètre.
- CopyOptions est arbitraire! Vous pouvez le mettre ici si vous le souhaitez.
- maintenant, ce est ce que je cherchais! JDK à la rescousse, pas besoin d'une autre bibliothèque
- Pour info, Files n'est PAS disponible dans Android's de Java 1.7. J'ai été piqué par ceci: stackoverflow.com/questions/24869323/...
- De manière amusante, le JDK a aussi un Files.copy() qui prend deux cours d'eau, et est ce que tous les autres Files.copy() fonctions de l'avant afin de faire le travail de copie. Cependant, il est privé (car il ne fait pas les impliquer les Chemins ou les Fichiers à ce stade), et regarde exactement comme le code dans le cas des OP propre question (en plus d'une instruction de retour). Pas d'ouverture, pas de fermeture, juste une copie de la boucle.
- Pour Java 9 et les versions ultérieures, utilisez InputStream.transferTo(OutputStream). stackoverflow.com/a/39440936/1441122
- Files.copy n'ont pas en arrière support pour l'API en dessous de 26 @user1079877
InformationsquelleAutor user1079877
100

Je pense que cela va fonctionner, mais assurez-vous de le tester... mineur "amélioration", mais il pourrait être un peu d'un coût à la lisibilité.
```
byte[] buffer = new byte[1024];
int len;
while ((len = in.read(buffer)) != -1) {
    out.write(buffer, 0, len);
}
```
- Je suggère une zone tampon d'au moins 10K à 100K. Ce n'est pas beaucoup et peut accélérer la copie de grandes quantités de données énormément.
- Cela a fait l'affaire pour moi lors de l'écriture d'un fichier. Je n'ai pas réalisé que j'ai besoin pour obtenir la longueur réelle readd à partir du flux d'entrée et de l'utiliser pour la sortie vers un fichier.
- vous voudrez peut-être dire while(len > 0) au lieu de != -1, parce que cette dernière pourrait également renvoyer 0 lors de l'utilisation de la read(byte b[], int off, int len)-méthode, qui déclenche une exception @ out.write
- Ce serait incorrect, car il est tout à fait légal selon le InputStream contrat de lecture pour retourner 0 un nombre quelconque de fois. Et selon la OutputStream contrat, la méthode d'écriture doit accepter une longueur de 0, et ne doit lever une exception lorsque len est négatif.
- Vous pouvez enregistrer une ligne par la modification de la while à un for et de mettre l'une des variables pour l'initialisation de l'article: par exemple, for (int n ; (n = in.read(buf)) != -1 ;) out.write(buf, 0, n);. =)
- ne peut revenir à zéro si vous avez fourni une longueur de zéro, ce qui serait une erreur de programmation, et un stupide condition de la boucle pour toujours. Et write() n' pas lancer une exception si vous fournissez une longueur nulle.
- Il est pas juridique pour InputStream.read(byte[] b) pour revenir à 0 (sauf si vous êtes stupide comme EJP dit: Si la longueur de b est égal à zéro, alors pas d'octets sont lus et la valeur renvoyée est 0; sinon, il y a une tentative de lecture d'au moins un octet. Si aucun octet est disponible, car le flux est à la fin du fichier, la valeur -1 est renvoyée; sinon, au moins un octet est lu et stocké dans b.
- Merci! Je n'ai jamais réalisé. Je pourrais imaginer des cas d'utilisation si vous souhaitez passer un zéro de la longueur de la mémoire tampon, ou lorsqu'il se produit pour d'autres raisons. Ainsi, tout comme je porte toujours ma ceinture de sécurité, je vais toujours vérifier -1. L'arrêt de la lecture et de rejeter les données restantes est au moins autant une erreur que de passer un tampon vide.
- Il n'y a aucune autre raison:seul un zéro-longueur de la mémoire tampon ou une longueur de zéro paramètre. Le sens de votre dernière phrase m'échappe.
InformationsquelleAutor Mike Stone
51

À l'aide de la Goyave est ByteStreams.copier():
```
ByteStreams.copy(inputStream, outputStream);
```
- Ne pas oublier de fermer le flux de suite!
- C'est la meilleure réponse si vous êtes déjà à l'aide de Goyave qui est devenu indispensable pour moi.
- Vous devez utiliser Files.copy autant que possible. Utilisation ByteStreams.copy seulement si les deux flux ne sont FileInputStream/FileOutputStream.
- Merci pour l'astuce. Dans mon cas, le flux d'entrée est à partir d'une application Android de la ressource (drawable).
InformationsquelleAutor Andrejs
25

Fonction Simple

Si vous avez seulement besoin de cela pour écrire un InputStream à un File alors vous 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();
    }
}
```
- La grande fonction, merci. Auriez-vous besoin pour mettre la close() appels en finally blocs, si?
- Il ne ferait pas de mal.
- Vous devriez probablement les deux comprennent enfin un bloc et de ne pas avaler les exceptions dans une mise en œuvre effective. Aussi, la fermeture d'un InputStream passés à une méthode est parfois inattendu par l'appel de la méthode, de sorte que l'on devrait envisager si c'est le comportement qu'ils veulent.
- Pourquoi intercepter l'Exception lorsque IOException suffit?
InformationsquelleAutor Jordan LaPrise
16

PipedInputStream et PipedOutputStream ne doit être utilisé lorsque vous avez plusieurs threads, comme noté par la Javadoc.

Notez également que les flux d'entrée et les flux de sortie n'enroulez pas de n'importe quel thread interruptions avec IOExceptions... Donc, vous devriez envisager l'intégration d'une politique d'interruption de 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 complément utile si vous prévoyez d'utiliser cette API pour la copie de gros volumes de données, ou des données de flux coincé pour un insupportablement longue période de temps.

InformationsquelleAutor Dilum Ranatunga

La JDK utilise le même code de sorte qu'il semble qu'il y est pas "facile" sans maladroit de bibliothèques tierces (qui n'est probablement pas faire quoi que ce soit de toute façon). Ce qui suit est directement copié à partir 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;
    }

Aye. Honte à cet appel d'offres est privé et il n'y a pas d'autre choix que de le copier dans votre propre classe d'utilitaires, puisqu'il est possible que vous n'avez pas affaire avec les fichiers, mais plutôt de 2 prises à la fois.

InformationsquelleAutor BullyWiiPlaza

13

Pour ceux qui utilisent framework Spring il est utile de StreamUtils classe:
```
StreamUtils.copy(in, out);
```
Ci-dessus n'est pas de fermer les volets. Si vous souhaitez que les flux fermé après la copie, l'utilisation FileCopyUtils classe à la place:
```
FileCopyUtils.copy(in, out);
```
InformationsquelleAutor holmis83
8

Il n'y a pas moyen de faire beaucoup plus facile avec le JDK méthodes, mais comme Apocalisp a déjà noté, vous n'êtes pas la seule à avoir cette idée: Vous pouvez utiliser IOUtils de Jakarta Commons IO, elle a aussi beaucoup d'autres choses utiles, que l'OMI devrait faire partie du JDK...

InformationsquelleAutor WMR

À l'aide de Java7 et try-with-resources, vient avec un simplifiée et lisible de la version.

    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();
    }

Le rinçage à l'intérieur de la boucle est hautement contre-productif.

InformationsquelleAutor Sivakumar

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);
    }
}

InformationsquelleAutor Jin Kwon

Utiliser Communes Net Util classe:

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

InformationsquelleAutor DejanLekic

3

Un à mon humble avis plus minime fragment (qui a également plus étroitement les étendues de la longueur variable):
```
byte[] buffer = new byte[2048];
for (int n = in.read(buffer); n >= 0; n = in.read(buffer))
    out.write(buffer, 0, n);
```
Comme une note de côté, je ne comprends pas pourquoi plus de gens ne les utilisent pas un for boucle, plutôt que d'opter pour un while avec un attribuez-et-expression de test qui est considéré par certains comme des "pauvres" de style.
- Votre suggestion causes de 0 octets à écrire sur la première itération. Peut-être moins à faire: for(int n = 0; (n = in.read(buffer)) > 0;) { out.write(buffer, 0, n); }
- Vous avez raison à propos de la première itération est incorrect. Le code a été corrigé (à mon humble avis, d'une manière plus propre que votre suggestion) - voir édité code. Thx pour les soins.
InformationsquelleAutor Bohemian
2

Je pense qu'il est préférable d'utiliser une mémoire tampon de grande taille, car la plupart des fichiers sont supérieurs à 1024 octets. Aussi c'est une bonne pratique pour vérifier le nombre d'octets lus à être positif.
```
byte[] buffer = new byte[4096];
int n;
while ((n = in.read(buffer)) > 0) {
    out.write(buffer, 0, n);
}
out.close();
```
- À l'aide d'un tampon de grande est en effet une bonne idée, mais pas parce que les fichiers sont le plus souvent > 1k, c'est pour amortir le coût des appels système.
InformationsquelleAutor Alexander Volkov
0

PipedInputStream et PipedOutputStream peut être de quelque utilité, comme vous pouvez connecter l'un à l'autre.
- Ce n'est pas bon pour single-threaded code qu'il pourrait l'impasse; voir à cette question, stackoverflow.com/questions/484119/...
- Peut être de quelque utilité, comment? Il a déjà un flux d'entrée et un flux de sortie. Comment ajouter un autre de chaque aide exactement?
InformationsquelleAutor Arktronic
0

Un autre candidat possible sont la Goyave I/O utilities:

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

Je pensais utiliser ces depuis Goyave est déjà extrêmement utile dans mon projet, plutôt que d'ajouter encore une autre bibliothèque pour une fonction.
- Il y a copy et toByteArray méthodes de docs.guava-libraries.googlecode.com/git-history/release/javadoc/... (goyave appels d'entrée/sortie flux "octet flux" et les lecteurs/écrivains comme "char flux")
- si vous utilisez déjà la goyave, les bibliothèques, c'est une bonne idée, mais si pas, ils sont une grande bibliothèque avec des milliers de méthodes de "google-chemin-de-faire-tout-différent-de-la-norme". J'avais tenir loin d'eux
InformationsquelleAutor Andrew Mao

- Je utiliser BufferedInputStream et BufferedOutputStream pour supprimer la mise en mémoire tampon de la sémantique du code

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

InformationsquelleAutor Archimedes Trajano

C'est mon meilleur coup!!!!

Et ne pas utiliser inputStream.transferTo(...) parce que c'est trop générique.
Votre code rendement sera meilleur si vous le contrôle de 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'utiliser avec ce (améliorable) méthode quand je sais à 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
    );
}

InformationsquelleAutor Daniel De León

-2

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;
}

Pouvez-vous expliquer pourquoi c'est la bonne réponse?

InformationsquelleAutor Nour Rteil

-2

Essayer 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

InformationsquelleAutor yegor256

-5

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){}
 }

catch(Exception ex){} — c'est top

InformationsquelleAutor Pranav

Vous devez vous connecter pour publier un commentaire.

Java 9

Fonction Simple