Vue d'ensemble du flux io:
Le flux IO est utilisé pour traiter la transmission de données entre les périphériques, télécharger des fichiers et télécharger des fichiers. Java manipule les données en mode flux. Les objets que Java utilise pour manipuler les flux sont tous dans le package IO.
Classification des flux d'E / S
Selon le flux de données
Flux d'entrée pour lire les données
Le flux de sortie écrit des données
Selon le type de données
Flux d'octets
Flux de caractères
Quel flux doit être utilisé dans quelles circonstances?
Si le fichier dans lequel se trouvent les données est ouvert via le bloc-notes fourni avec Windows et peut lire le contenu à l'intérieur, utilisez le flux de caractères et d'autres utilisent le flux d'octets.
Si vous ne savez rien, utilisez des flux d'octets.
Classe de base couramment utilisée pour le flux IO
Classe de base abstraite du flux d'octets:
InputStream ， OutputStream。
Classe de base abstraite du flux de caractères:
Lecteur ， Écrivain。
Remarque: les
noms des sous-classes dérivées de ces quatre classes sont tous suffixés avec leur nom de classe parent.
Tels que: FileInputStream, une sous-classe d'InputStream.
Tels que: FileReader, une sous-classe de Reader.
FileOutputStream, une sous-classe de OutputStream
Méthode de construction:
FileOutputStream (fichier fichier)
FileOutputStream (nom de chaîne)
La deuxième méthode de construction est recommandée:
FileOutputStream outputStream = nouveau FileOutputStream ("a.txt"); 1
Créez un objet de flux de sortie d'octets et effectuez plusieurs opérations:
A: Appelez la fonction système pour créer un fichier B: Créez un objet outputStream C: Pointez l'objet foutputStream vers ce fichier 123
Écrire des données dans du texte via un flux de sortie d'octets
public void write (int b) public void write (byte [] b) public void write (byte [] b, int off, int len) 123
Comme le montre la méthode, il ne peut être écrit que par octet
outputStream.write ("hello" .getBytes ()); bonjour apparaît dans le texte
outputStream.write (96) // apparaît dans le texte un
octet [] bys = {97,98,99,100,101};
outputStream.write (bys, 1, 3); bcd12345 apparaît dans le texte
Écrivez de cette manière, les données dans le texte ne seront pas enveloppées ou ajoutées, et chaque fois qu'elles sont écrites, l'original sera écrasé.
ajouter à:
FileOutputStream outputStream = new FileOutputStream ("a.txt", true);
// Le deuxième paramètre true est défini comme pouvant être ajouté. 12
Nouvelle ligne \ n \ r:
for (int i = 0; i <5; i ++) {
outputStream.write ("bonjour" .getBytes ());
outputStream.write ("\ n \ r" .getBytes ());
} 1234
Remarque: n'oubliez pas de fermer le flux lorsque vous avez terminé.
outputStream.close (); 1
Exemple complet:
package io2;
import java.io.FileOutputStream;
import java.io.IOException;
/ **
* new FileOutputStream ("a.txt", true); Le deuxième paramètre est true, défini pour écrire des données épissées à la fin
* \ n \ r Saut de ligne
* write (bys, 1,3); write byte array
* /
public class out {
public static void main (String args []) {
FileOutputStream outputStream = null;
try {
// FileOutputStream fos = new FileOutputStream (file);
outputStream = new FileOutputStream ("a.txt", true);
/ *
* Créez un objet de flux de sortie d'octets et faites plusieurs choses:
* A: appelez la fonction système pour créer un fichier
* B: créez un objet outputStream
* C: pointez l'objet foutputStream vers ce fichier
* /
// for (int i = 0; i <5; i ++) {
// outputStream.write ("bonjour" .getBytes ());
// outputStream.write ("\ n \ r" .getBytes ());
//}
byte [] bys = {97,98,99,100,101};
outputStream.write (par, 1,3);
} catch (IOException e) {
e.printStackTrace ();
}
enfin {
essayez {
outputStream.close ();
} catch (IOException e) {
e.printStackTrace ();
}
}
}
} 12345678910111213141516171819202122232425262728293031323334353637383940414243
Sous-classe de InputStream FileInputStream
Méthode de construction FileInputStream
FileInputStream (fichier fichier) FileInputStream (nom de chaîne) 12
La deuxième méthode de construction est recommandée:
FileInputStream inputStream = nouveau FileInputStream ("a.txt"); 1
Maintenant, lisez les données qui viennent d'être écrites sur la console:
public int read () public int read (octet [] b) 12
La première lecture consiste à lire un octet et la deuxième lecture à lire un tableau d'octets.
// 读 一个 字节
int by = 0;
while ((by = inputStream.read ())! = - 1) {
System.out.println ((char) by);
} 12345
S'il n'y a pas de données, il renverra -1. Ceci est utilisé pour juger si la lecture est terminée.
// Lit un tableau d'octets, généralement de taille 1024
int len = 0;
byte [] bys = new byte [1024];
while ((len = inputStream.read (bys))! = -1) {
System.out. println (nouvelle chaîne (bys, 0, len));
} 123456
Les valeurs de retour des deux lectures sont légèrement différentes, read () renvoie l'octet lu, et -1 à la fin de la lecture, read (byte [] b) retourne le nombre d'octets lus, l'octet lu Mettez-le dans le tableau d'octets d'octets et renvoie -1 s'il n'y a pas de données à la fin.
Schéma de deux méthodes de lecture:
[Échec du transfert de l'image du lien externe. Le site source dispose peut-être d'un mécanisme de lien anti-sangsue. Il est recommandé d'enregistrer l'image et de la télécharger directement (img-Yv0oyKLy-1603813798619) (http://p5kllyq5h.bkt.clouddn.com/ 174401.jpg)]
Lorsque le flux est épuisé, il doit être fermé à temps pour éviter l'utilisation de la mémoire.
inputStream.close (); 1
Exemple complet:
Il est recommandé de lire les données dans un tableau d'octets.
package io2;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
/ **
* Créé par stefan
* Date le 27/05/2018 23:00
* Conversion sur configuration!
* /
public class input2 {
public static void main (String args []) {
FileInputStream inputStream = null;
essayez {
inputStream = new FileInputStream ("a.txt");
// octet [] bys = nouvel octet [4];
// int len = inputStream.read (bys);
// System.out.println (nouvelle chaîne (bys)); // bcd
// System.out.println (len); // 3
// System.out.println (inputStream.read (bys)); //-1
int len = 0;
byte [] bys = nouvel octet [1024];
while ((len = inputStream.read (bys))! = -1) {
System.out.println (new String (bys, 0, len));
}
/ **
* public String (byte bytes []) {
this (bytes, 0, bytes.length);
}
* /
} catch (IOException e) {
e.printStackTrace ();
} enfin {
essayez {
inputStream.close ();
} catch (IOException e) {
e.printStackTrace ();
}
}
}
} 123456789101112131415161718192021222324252627282930313233343536373839404142434445
Fichier de copie de flux d'octets
Utilisez le flux d'entrée pour lire les octets dans un fichier, puis utilisez le flux de sortie pour écrire les octets lus dans un autre fichier (il sera créé automatiquement s'il n'existe pas)
package io2;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
/ **
* Créé par stefan
* Date le 27/05/2018 23:19
* Conversion sur configuration!
* /
public class copy {
public static void main (String args []) jette IOException {
FileInputStream inputStream = new FileInputStream ("E: \\ giant1.jpg");
FileOutputStream outputStream = nouveau FileOutputStream ("E: \\ 古 月 .jpg");
octet [] octets = nouvel octet [1024];
int len = 0;
while ((len = inputStream.read (bytes))! = -1) {
outputStream.write (octets, 0, len);
}
inputStream.close ();
outputStream.close ();
}
} 12345678910111213141516171819202122232425262728
Remarque: la méthode de copie de texte, d'images, de mp3, de vidéo, etc. est la même.
La vitesse de lecture et d'écriture d'un flux d'octets sur un tableau à la fois est évidemment beaucoup plus rapide que la vitesse de lecture et d'écriture octet par octet. C'est l'effet de l'ajout d'un tampon tel qu'un tableau.
Lorsque Java lui-même a été conçu, il a également pris en compte ces idées de conception (expliquées plus loin dans le modèle de conception décorative), de sorte qu'il fournit un flux de tampon d'octets.
Byte buffer output stream BufferedOutputStream Byte buffer input stream BufferedInputStream 1234
BufferedOutputStream
BufferedOutputStream bos = nouveau BufferedOutputStream (nouveau FileOutputStream ("a.txt", true));
bos.write ("bonjour le monde" .getBytes ());
bos.close (); 123
BufferedInputStream
BufferedInputStream bis = nouveau BufferedInputStream (nouveau FileInputStream ("a.txt"));
octet [] octets = nouvel octet [1024];
int len = 0;
while ((len = bis.read (bytes))! = -1) {
System.out.println (new String (bytes, 0, len));
}
bis.close (); 1234567
Remarque:
-
La méthode membre est fondamentalement la même que le flux d'octets, et la fonction du flux de tampon d'octets est d'améliorer l'efficacité de l'entrée et de la sortie.
-
La méthode de construction peut spécifier la taille du tampon, mais nous ne l'utilisons généralement pas, car la taille par défaut du tampon est suffisante.
-
Pourquoi ne pas passer un fichier ou un chemin de fichier spécifique, mais passer un objet OutputStream? La raison est très simple, le flux de tampon d'octets ne fournit qu'un tampon, conçu pour l'efficacité. Cependant, les véritables opérations de lecture et d'écriture doivent s'appuyer sur des objets de flux de base.
Mise à niveau des fichiers copiés:
BufferedOutputStream bos = nouveau BufferedOutputStream (nouveau FileOutputStream ("E: \\ modern-java.pdf"));
BufferedInputStream bis = nouveau BufferedInputStream (nouveau FileInputStream ("F: \\ 汤包 \\ 慕 课 大巴 \\ modern-java.pdf"));
int len = 0;
octet [] octets = nouvel octet [1024];
while ((len = bis.read (octets))! = -1) {
bos.write (octets, 0, len);
}
bis.close ();
bos.close (); 123456789
Test: l'efficacité des quatre types de fichiers de copie
package io2;
import java.io. *;
/ **
*
* Temps de copie du test
* Création par stefan
* Date du 28/05/2018 à 10h28
* Conversion via la configuration!
* /
public class copy2 {
// Un octet Cela prend 22697 millisecondes pour copier un octet
public static void fun () jette IOException {
FileInputStream fis = new FileInputStream ("F: \\ soupbag \\ modern-java.pdf");
FileOutputStream fos = new FileOutputStream ("E: \\ modern- java.pdf ");
int by = 0;
while ((by = fis.read ())! = -1) {
fos.write (by);
}
fis.close ();
fos.close ();
}
/ / La copie du tableau de 1024 octets prend 63 millisecondes
public static void fun1 () lance IOException {
FileInputStream fis = new FileInputStream ("F: \\ soupbag \\ MO Class Bus \\ modern-java.pdf");
FileOutputStream fos = new FileOutputStream ("E: \\ modern- java .pdf ");
int len = 0;
byte [] bytes = new byte [1024];
while ((len = fis.read (bytes))! = -1) {
fos.write (bytes, 0, len );
}
fis.close ();
fos.close ();
}
// Copie un octet par un octet, mais le flux mis en mémoire tampon prend 64 millisecondes
public static void fun2 () lance IOException {
BufferedOutputStream bos = new BufferedOutputStream (new FileOutputStream ( "E: \\ modern-java.pdf"));
BufferedInputStream bis = new BufferedInputStream (new FileInputStream ("F: \\ soupbag \\ moo class bus \\ modern-java.pdf"));
int by = 0;
while ((by = bis.read ())! = -1) {
bos. write (by);
}
bis.close ();
bos.close ();
}
// Le tableau de 1024 octets est copié et le flux mis en mémoire tampon est utilisé. Cela prend 7 millisecondes
public static void fun3 () jette IOException {
BufferedOutputStream bos = new BufferedOutputStream (new FileOutputStream ("E: \\ modern-java.pdf"));
BufferedInputStream bis = new BufferedInputStream (new FileInputStream ("F: \\ soupbag \\ MO Class Bus \\ modern-java.pdf")) ;
int len = 0;
byte [] bytes = new byte [1024];
while ((len = bis.read (bytes))! = -1) {
bos.write (octets, 0, len);
}
bis.close ();
bos.close ();
}
public static void main (String args []) lève IOException {
long t1 = System.currentTimeMillis ();
fun3 ();
long t2 = System.currentTimeMillis ();
System.out.println (t2-t1);
}
} 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768