Qu'est-ce que InputStream & Output Stream? Pourquoi et quand les utilisons-nous?

Quelqu'un m'explique quoi InputStreamet quoi OutputStream?

Je suis confus quant aux cas d'utilisation pour InputStreamet OutputStream.

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

Le but de InputStreamet OutputStreamest d'abstraire différentes façons d'entrer et de sortir: que le flux soit un fichier, une page Web ou l'écran ne devrait pas avoir d'importance. Tout ce qui compte, c'est que vous receviez des informations du flux (ou que vous envoyiez des informations dans ce flux).

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

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

Voici un exemple de code. Il suppose que InputStream instret OutputStream osstront déjà été créés:

int i;

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

instr.close();
osstr.close();

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 pouvez lire / écrire tous les différents types de données de tous les 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 pour l'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).

Depuis le 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:

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

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 les fichiers de disque , mais une source ou une destination peut également être un autre programme, un périphérique, une prise réseau ou une matrice .

Exemple de code du tutoriel 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 les flux octets à copier xanadu.txt fichier à outagain.txt , en écrivant un octet à la fois

Jetez un œil à 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

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

par exemple, supposons que vous souhaitiez copier un fichier. Vous devez créer un FileInputStream pour lire à partir du fichier source et un FileOutputStream pour é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();

OutputStream est une classe abstraite qui représente l'écriture de sortie. Il existe de nombreuses classes OutputStream différentes, et elles écrivent sur certaines choses (comme l'écran, ou Files, ou des tableaux d'octets, ou des connexions réseau, ou 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.

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

Le flux Java est un flux de données d'une source vers 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 pour les 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 de la partie dynamique du flux.

InputStreamreprésente un flux de données depuis la source, le OutputStreamreprésente un flux de données vers la destination. Enfin, InputStreamet OutputStreamsont des abstractions sur l'accès de bas niveau aux données, telles que les pointeurs de fichier C.

Flux : En termes simples, le flux est des données, le flux le plus générique est une représentation binaire des données.

Flux d'entrée : si vous lisez des données à partir 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 agit comme un canal pour lire les données.

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

Un flux de sortie est généralement lié à une destination de données comme un fichier ou un réseau, etc. En Java, le flux de sortie est une destination où 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");
    }
}