1. Streams d'entrée de base et flux de sortie <BR /> Le flux est l'un des concepts de base les plus importants de Java. La lecture et l'écriture de fichiers, la transmission et la réception du réseau, la communication de processus et le streaming sont utilisés dans presque tous les endroits où l'entrée et la sortie sont nécessaires.
À quoi sert le streaming? C'est pour l'entrée et la sortie. Pourquoi l'entrée et la sortie utilisent-elles "Stream"? Étant donné que l'unité de base de l'entrée et de la sortie du programme est des octets, l'entrée est d'obtenir une chaîne d'octets et la sortie consiste à envoyer une chaîne d'octets. Cependant, dans de nombreux cas, il est impossible pour un programme de recevoir tous les octets avant le traitement, mais de recevoir un peu de traitement. Par exemple, lorsque vous téléchargez World of Warcraft, il est impossible de tout télécharger en mémoire et de l'enregistrer sur le disque dur, mais il suffit de le télécharger et de le sauver un peu. Pour le moment, cette méthode est très adaptée.
En Java, chaque flux est un objet. Il existe deux types de flux: le flux d'entrée (InputStream) et le flux de sortie (OutputStream). Pour le flux d'entrée, il vous suffit de continuer à éliminer les octets du flux;
Comment les objets de flux sont-ils obtenus? Différents systèmes externes ont également différentes façons d'obtenir des flux. Par exemple, lors de la lecture et de l'écriture de fichiers, vous devez créer un objet FileInputStream / FileOutputStream, tandis que la communication réseau utilise des objets Socket pour obtenir des flux d'entrée et de sortie. D'une manière générale, si une classe a des méthodes telles que getInputStream () ou getOutputStream (), cela signifie qu'il est entrée et sortie via un objet Stream.
InputStream est un flux d'entrée.
Importer Java.io.File; * / classe publique ReadFileDemo {// Entrée du programme Public Static void main (String [] Args) {String Path = "C: /boot.ini"; ; BYTE [0]; Si la valeur de retour est -1, cela signifie qu'il n'y a pas de contenu à lire. tandis que (chaque fois! = -1) {// Le contenu de lecture est placé dans le tampon et le fusionne maintenant dans le contenu. Content = ConcatByTearRays (contenu, tampon, chaque fois); printStackTrace ();} Enfin {try {is.close ();} catch (ioException e) {// Les exceptions peuvent être ignorées et non traitées} // le fichier de sortie contente contentetr = new String (contenu); em. Renvoie le résultat de la fusion de la première taille OfBytestes2 Bytes1 et ByTES2 * / octet statique privé [] ConcatByTeArrays (byte [] bytes1, octet [] bytes2, int sizeofbytes2) {octet [] resu lt = arrays.copyof (bytes1, (bytes1 .Length + sizeofbytes2));Bien qu'il soit très verbeux, c'est en effet l'utilisation de base de l'entrée. Notez que ce n'est qu'un exemple de la façon de lire une chaîne d'octet à partir du flux d'entrée. En fait, Java fournit un moyen plus facile de lire les fichiers texte. Il sera introduit plus tard.
L'utilisation de la sortie OutputStream est une chose très simple que de lire à partir d'un flux. Voici un exemple:
Importer java.io.outputStream; SaveFileDemo {public static void main (String [] args) lance ioException {String path = "c: /Now.txt"; ()) {System.err.println ("Le fichier ne peut pas être créé."); ) .toString () .getBytes ()); System.out.println ("L'écriture de fichiers est terminée.");
Java fournit également d'autres opérations de streaming, mais ils étendent ou enveloppent tous les engrais et OutputStream. Ces deux classes sont donc la base et elles doivent être comprises.
2. Lecteur et écrivain
InputStream et OutputStream sont introduits, puis le lecteur et l'écrivain sont introduits. Ces deux classes enveloppent en réalité l'entrée et OutputStream. Cependant, ils traitent non pas des octets, mais des personnages. Si le contenu dans un flux est du texte, il sera plus facile de traiter avec le lecteur / écrivain. Voici un exemple de lecture d'un fichier texte à l'aide du lecteur:
import java.io.fileReader; String Path = "C: /boot.ini"; String Content = ""; lire (tampon))! = -1) {Content + = new String (tampon, 0, count);}} catch (ioException e) {System.err.println ("Le fichier de lecture a échoué."); ));Quant à l'utilisation de l'écrivain pour écrire du contenu de texte dans un fichier, je n'en donnerai pas un exemple.
L'exemple ci-dessus n'est toujours pas le moyen le plus courant de lire les fichiers texte. Java fournit un BufferedReader, que nous utilisons généralement pour lire les fichiers texte. Voici un exemple:
Importer java.io.BufferedReader; Path = "C: /boot.ini"; String Content = ""; {Content + = Line + "/ N";}} Catch (ioException e) {System.err.println ("Le fichier de lecture a échoué."); }3. Sérialisation des objets <BR /> La sérialisation des objets est également un aspect important des applications de streaming. La sérialisation consiste à convertir un objet en une chaîne d'octets, qui peut être enregistré ou transmis à un autre programme Java à utiliser. ObjectOutputStream et ObjectInputStream sont spécialement utilisés pour la sérialisation et la désérialisation. Voici un exemple simple:
importation java.io.ObjectOutStstream; Importer java.io.eofException; * Ces deux classes sont utilisées pour la sérialisation et la désérialisation respectivement. * / public class SerializationDemo {public static void main (String [] args) exception {String path = "c: /persons.data"; F.CreateEwFile ();} WritePersons (Path); PATH)); personne P; L'objet est enregistré dans le fichier spécifié Private Static Void WritePersons (String Path) lance IoException {Person [] Persons = New Person [] {New Person ("Zhang San", 23), New Person ("Li Si", 24)} ; ///////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////DROB ////////////////////////////////////////////////////////////////////////// / ////////////////////////////////////////////////////////////////////////// / ////////////////////////////////////////////////////////////////////////// / ////////////////////////////////////////////////////////////////////////// / //////////////// Personne implémente Serializable {Private String Name; Private int Age; this.a ge = age;} public string getName () {Nom de retour;} public netname (nom de la chaîne) {this.name = name; {this.age = age;} @Override public String toString () {return "Person {" + "name = '" + name +' / '' + ", age =" + age + '}';Cet exemple ne peut pas lire et écrire des octets et des caractères, car les deux classes sont emballées. Ce qui précède est juste un exemple simple, et il y a encore beaucoup de choses à faire attention si vous voulez bien écrire la sérialisation. Si vous voulez avoir une compréhension plus profonde de la sérialisation, vous pouvez le vérifier ici. Cet article se concentre uniquement sur les pièces liées au streaming. En fait, la sérialisation est rarement utilisée car la sérialisation réduit la flexibilité, elle n'est donc généralement pas utilisée si vous ne l'utilisez pas.