Cet article décrit les méthodes de lecture et d'écriture de fichiers dans la programmation Java. Partagez-le pour votre référence, comme suit:
Quel est le rôle des opérations de lecture et d'écriture de fichiers en Java?
Lorsque vous répondez à cette question, vous devez d'abord penser que Java n'est qu'une langue, notre outil d'utilisation, donc la réponse est claire, c'est-à-dire d'écrire diverses données étrangères dans un certain fichier pour le stockage; ou lisez ses données du fichier à utiliser. Tout comme le processus de film suivant, téléchargez un film à partir des ressources réseau et enregistrez-le sur votre ordinateur (écrivez un fichier) et utilisez le lecteur pour l'ouvrir (lisez le fichier) lorsque vous souhaitez le regarder.
Comment lire et écrire des fichiers en Java?
Comprenons d'abord. Il existe deux types de flux en Java, des flux d'octets et des flux de caractères. Les deux classes de base de flux d'octets sont InputStream et OutputStream; Les deux classes de base de flux de personnages sont le lecteur et l'écrivain. Le soi-disant flux de fichiers signifie que nous ne pouvons pas quitter le flux lorsque nous exploitons le fichier. De cela, nous pouvons voir que nous voulons utiliser une certaine classe qui doit hériter de l'une des quatre classes de base comme ci-dessus. Tout en Java est une classe et tout est un objet. Naturellement, vous penserez aux types d'opérations de fichiers:
Les quatre classes directement utilisées:
Byte Stream: FileInputStream et FileOutputStream
Stream de caractères: FileReader et Filewriter
Il est facile de trouver la classe. Le reste est de trouver un moyen de le mettre en œuvre.
Il y a deux options ici, qui impliquent la façon dont nous choisissons la bonne façon de lire et d'écrire des fichiers?
Différences dans les critères de sélection:
Lisez des fichiers en octets, qui sont souvent utilisés pour lire des fichiers binaires, tels que des images, des sons, des images et d'autres fichiers.
Lisez des fichiers en unités de caractères et sont souvent utilisés pour lire des fichiers de texte, de chiffres, etc.
Quant à utiliser un tampon pour résumer le flux d'entrée et de sortie du fichier, cela dépend de la taille du fichier. S'il s'agit d'une lecture et d'une écriture de fichiers importants, le seau de tampon est sélectionné pour fournir une efficacité de lecture et d'écriture de fichiers.
Ce qui suit est un exemple d'application simple:
1. Utilisez le flux BYTE pour lire et écrire des fichiers directement:
Remarque: fileOutputStream (fichier, true); le paramètre True dans FileOutputStream (fichier, true); Indique que le fichier d'origine n'est pas écrasé et que le contenu est ajouté directement après le fichier.
classe publique FileSTest {fichier statique Fichier = nouveau fichier ("d: /test.txt"); public static void main (String [] args) {try {fileoutputStream out = new FileOutputStream (file, true); String s = "Hello, world! / r / n"; out.write (s.getbytes ()); out.flush (); out.close (); // filein) FileInputStream (fichier); // byte [] b = new octet [20]; // in.read (b, 0, b.length); // system.out.println (new String (b)); // in.close ();} catch (filenotfoundException e) {e.printStackTrace ();} catch (ioException e) e) {e.printStackTrace ();}}}2. Utilisez des flux de caractères pour lire et écrire des fichiers directement:
public class File03 {static file file = new File ("d: /test.txt"); public static void main (String [] args) {try {filewriter fw = new filewriter (file, true); fw.write ("hello, world! / r / n"); fw.flush (); fw.close (); // filerader fr = new Freater (file); i = 0; // String s = ""; // while ((i = fr.read ())! = -1) // {// s = s + (char) i; //} // system.out.println (s);} catch (filenotfoundException e) {e.printStStackTrace ();} catch (ioException e) {e.printStackTrace ();Utilisation des flux de lecture et d'écriture de fichiers après avoir été encapsulé avec du tampon:
1. Lire et écrire des fichiers après encapsulation du flux d'octets:
Fichier statique = nouveau fichier ("d: /test.txt"); public static void main (String [] args) {try {// fileoutputStream out = new FileOutputStream (file, true); // buffredoutputStream bouton = bouts.flush (); // bouts.close (); fileInputStream dans = new FileInputStream (fichier); tampheredInputStream bin = new BufferedInputStream (in); byte [] b = new Byte [15]; bin.read (b); bin.close (); System.out.println (new String (b));} capture (filotfound e) {e.printStackTrace ();} catch (ioException e) {e.printStackTrace ();}}}2. Lire et écrire des fichiers après avoir encapsulé le flux de caractères:
public class File03 {static File File = new File ("d: /test.txt"); public static void main (String [] args) {try {// filewriter fw = new filewriter (file, true); // buffredwriter bw = new buffredwriter (fw); // string nextline = System.getProperty ("line.seParator"); // bwwrite ("world! + nextline); // bw.flush (); // bw.close (); fileReader fr = new FileReader (fichier); buffereDreader br = new buttereDaDer (fr); int i = 0; string s = ""; string temp = null; while ((temp = br.readline ())! = null) {s = s + temp; (FilenotfoundException e) {e.printStackTrace ();} catch (ioException e) {e.printStackTrace ();}}}J'espère que cet article sera utile à la programmation Java de tous.