web-dev-qa-db-fra.com

Qu'est-ce que InputStream et Outputstream? Pourquoi et quand les utilisons-nous?

Quelqu'un m'explique ce que sont InputStream et OutputStream?

Je suis confus quant aux cas d'utilisation de InputStream et de OutputStream.

Si vous pouviez également inclure un extrait de code pour accompagner votre explication, ce serait formidable. Merci!

javaioinputstreamoutputstream
250
Bohemian

L'objectif de InputStream et OutputStream est de résumer différentes méthodes d'entrée et de sortie: que le flux soit un fichier, une page Web ou l'écran ne devrait pas avoir d'importance. Tout ce qui compte est que vous receviez des informations du flux (ou que vous envoyiez des informations dans ce flux).

InputStream est utilisé pour beaucoup de choses que vous lisez.

OutputStream est utilisé pour beaucoup de choses que vous écrivez.

Voici un exemple de code. Cela suppose que InputStream instr et OutputStream osstr ont déjà été créés:

int i;

while ((i = instr.read()) != -1) {
    osstr.write(i);
}

instr.close();
osstr.close();
194
Chip Uni

InputStream est utilisé pour la lecture, OutputStream pour l'écriture. Ils sont connectés en tant que décorateurs les uns aux autres de sorte que vous puissiez lire/écrire tous les différents types de données provenant de différents types de sources.

Par exemple, vous pouvez écrire des données primitives dans un fichier:

File file = new File("C:/text.bin");
file.createNewFile();
DataOutputStream stream = new DataOutputStream(new FileOutputStream(file));
stream.writeBoolean(true);
stream.writeInt(1234);
stream.close();

Pour lire le contenu écrit:

File file = new File("C:/text.bin");
DataInputStream stream = new DataInputStream(new FileInputStream(file));
boolean isTrue = stream.readBoolean();
int value = stream.readInt();
stream.close();
System.out.printlin(isTrue + " " + value);

Vous pouvez utiliser d'autres types de flux pour améliorer la lecture/écriture. Par exemple, vous pouvez introduire un tampon d’efficacité:

DataInputStream stream = new DataInputStream(
    new BufferedInputStream(new FileInputStream(file)));

Vous pouvez écrire d'autres données telles que des objets:

MyClass myObject = new MyClass(); // MyClass have to implement Serializable
ObjectOutputStream stream = new ObjectOutputStream(
    new FileOutputStream("C:/text.obj"));
stream.writeObject(myObject);
stream.close();

Vous pouvez lire à partir d'autres sources d'entrée différentes:

byte[] test = new byte[] {0, 0, 1, 0, 0, 0, 1, 1, 8, 9};
DataInputStream stream = new DataInputStream(new ByteArrayInputStream(test));
int value0 = stream.readInt();
int value1 = stream.readInt();
byte value2 = stream.readByte();
byte value3 = stream.readByte();
stream.close();
System.out.println(value0 + " " + value1 + " " + value2 + " " + value3);

Pour la plupart des flux d'entrée, il existe également un flux de sortie. Vous pouvez définir vos propres flux pour lire/écrire des choses spéciales et il existe des flux complexes pour lire des choses complexes (par exemple, il existe des flux pour lire/écrire au format Zip).

84
Arne Deutsch

À partir du Tutoriel Java :

Un flux est une séquence de données. 

Un programme utilise un flux d'entrée pour lire les données d'une source, un élément à la fois:

 enter image description here

Un programme utilise un flux de sortie pour écrire des données dans une destination, un élément à la fois:

 enter image description here

La source de données et la destination de données illustrées ci-dessus peuvent être tout ce qui contient, génère ou consomme des données. Évidemment, cela inclut disk files, mais une source ou une destination peut également être un autre programme, un périphérique, une prise réseau ou un tableau.

Exemple de didacticiel code from Oracle:

import Java.io.FileInputStream;
import Java.io.FileOutputStream;
import Java.io.IOException;

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

        FileInputStream in = null;
        FileOutputStream out = null;

        try {
            in = new FileInputStream("xanadu.txt");
            out = new FileOutputStream("outagain.txt");
            int c;

            while ((c = in.read()) != -1) {
                out.write(c);
            }
        } finally {
            if (in != null) {
                in.close();
            }
            if (out != null) {
                out.close();
            }
        }
    }
}

Ce programme utilise le flux d'octets pour copier le fichier xanadu.txt dans le fichier outagain.txt, en écrivant un octet à la fois

Jetez un oeil à cette question SE pour en savoir plus sur les flux de caractères avancés, qui sont des wrappers au-dessus des flux d'octets:

flux d'octets et flux de caractères

27
Ravindra babu

vous lisez à partir d'un InputStream et écrivez dans un OutputStream.

par exemple, supposons que vous souhaitiez copier un fichier. Vous créez un FileInputStream à lire à partir du fichier source et un FileOutputStream à écrire dans le nouveau fichier.

Si vos données sont un flux de caractères, vous pouvez utiliser un FileReader au lieu d'un InputStream et un FileWriter au lieu d'un OutputStream si vous préférez.

InputStream input = ... // many different types
OutputStream output = ... // many different types

byte[] buffer = new byte[1024];
int n = 0;
while ((n = input.read(buffer)) != -1)
    output.write(buffer, 0, n);

input.close();
output.close();
9
pstanton

OutputStream est une classe abstraite qui représente une sortie d'écriture. Il existe de nombreuses classes OutputStream différentes et elles écrivent certaines choses (comme l'écran, les fichiers, les tableaux d'octets, les connexions réseau, etc.). Les classes InputStream accèdent aux mêmes choses, mais elles y lisent des données.

Voici un bon exemple de base d'utilisation de FileOutputStream et FileInputStream pour écrire des données dans un fichier, puis les relire.

5
Kaleb Brasee

Un flux est un flux continu de liquide, d'air ou de gaz.

Le flux Java est un flux de données provenant d'une source ou dans une destination. La source ou la destination peut être un disque, une mémoire, un socket ou d’autres programmes. Les données peuvent être des octets, des caractères ou des objets. Il en va de même pour les flux C # ou C++. Une bonne métaphore des ruisseaux Java est l'eau qui coule d'un robinet dans une baignoire et plus tard dans un drainage.

Les données représentent la partie statique du flux; les méthodes de lecture et d'écriture constituent la partie dynamique du flux. 

InputStream représente un flux de données provenant de la source, la OutputStream représente un flux de données dans la destination ..__ Enfin, InputStream et OutputStream sont des abstractions sur un accès de bas niveau aux données, telles que les pointeurs de fichiers C.

2
Jan Bodnar

Courant: En termes simples, le flux correspond à données, le flux le plus générique étant une représentation binaire des données.

Flux d'entrée : Si vous lisez des données d'un fichier ou de toute autre source, le flux utilisé est le flux d'entrée. En termes plus simples, le flux d’entrée sert de canal pour lire les données.

Flux de sortie Si vous souhaitez lire et traiter des données d’une source (fichier, etc.), vous devez d’abord les enregistrer, le moyen de stocker des données est le flux de sortie.

2
Sher Mohammad

Un flux de sortie est généralement lié à une destination de données, telle qu'un fichier ou un réseau, etc.Dans le flux de sortie Java, les données sont finalement écrites et se terminent.

import Java.io.printstream;

class PPrint {
    static PPrintStream oout = new PPrintStream();
}

class PPrintStream {
    void print(String str) { 
        System.out.println(str)
    }
}

class outputstreamDemo {
    public static void main(String args[]) {
        System.out.println("hello world");
        System.out.prinln("this is output stream demo");
    }
}
0
Deep Arora

Flux d'entrée vs flux de sortie

Flux d'entrée

  • Ce flux est utilisé pour lire les données des fichiers

  • Les objets peuvent être créés à l'aide du mot-clé new. Plusieurs types de constructeurs sont disponibles.

  • Le constructeur suivant prend un nom de fichier en tant que chaîne pour créer un objet de flux d'entrée afin de lire le fichier.

    InputStream f = new FileInputStream("input.txt");

  • Le constructeur suivant prend un objet de fichier pour créer un objet de flux d'entrée afin de lire le fichier. Tout d'abord, nous créons un objet fichier en utilisant la méthode File () comme suit

    File f = new File(“input.txt");

    InputStream f = new FileInputStream(f);

Flux de sortie

  • FileOutputStream est utilisé pour créer un fichier et y écrire des données

  • Le flux créerait un fichier, s'il n'existe pas déjà, avant de l'ouvrir pour la sortie

  • Voici deux constructeurs pouvant être utilisés pour créer un objet FileOutputStream

  • Le constructeur suivant prend un nom de fichier sous forme de chaîne pour créer un objet de flux d'entrée afin d'écrire le fichier.

    OutputStream f = new FileOutputStream(“output.txt")

  • Le constructeur suivant utilise un objet de fichier pour créer un objet de flux de sortie afin d'écrire le fichier. Tout d'abord, nous créons un objet fichier en utilisant la méthode File () comme suit

    File f = new File(“output.txt");

    OutputStream f = new FileOutputStream(f);

0
Malith Ileperuma