Réponses:
Le but de InputStream
et OutputStream
est 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 instr
et OutputStream osstr
ont 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:
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();
close
flush
es toujours , donc non.
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.
InputStream
représente un flux de données depuis la source, le OutputStream
représente un flux de données vers la destination. Enfin, InputStream
et OutputStream
sont 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");
}
}