Cet article présente principalement l'utilisation des flux Java InputStream.
(1) FileInputStream: sous-classe, canal pour la lecture des données
Étapes à utiliser:
1. Obtenez le fichier cible: nouveau fichier ()
2. Créer un canal: new FileInputString ()
3. Read Data: Read ()
4. Ressources de libération: close ()
// Certains packages à importer par défaut Importent java.io.file; import java.io.fileInputStream; import java.io.ioException;
public static void main (String [] args) lève ioException {// Todo Méthode générée automatique Stub // Méthodes d'appel pour afficher l'effet test1();System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------(2) Trois façons de lire les données
1. Lire directement (un seul octet à la fois)
int date = fileInputStream.read (); CHAR DATE3 = (char) fileInputStream.read ();
// Imprimer public static void test1 () lève ioException {// (1) obtenir le fichier de cheminement de fichier cible fichier Fichier = nouveau fichier ("c: //users//joke//desktop//demo1.java"); // (2) créer une chaîne basée sur le parcours de fichier cible: nouveau fichier (fichier) fileinputtream wearInputStream = new FileInputStream (file) FileInputtream wearInputStream = new FileInputStream / (File) FileInStream FileInputStream = new FileInputStream / (File) FileInStream ReadingStream = new FileInputStream / (File) FileInStream ReadingStream = nouveau FileInStStret; data: read (); int date = fileInputStream.read (); // voici int type int date2 = fileInputStream.read (); // char date3 = (char) fileInputStream.read (); // afficher System.out.println (date + "//" + date2 + "//" + date3); // (4) Libérez la ressource FileInputStream.close ();}2. Utilisation pour les boucles seules (efficacité INE)
for (int i = 0; i <file.length (); i ++) {System.out.print ((char) fileInputStream.read ()); } // Méthode Two-Loop Traversal public static void test2 () lève ioException {// Test Efficiency Through Time Long Starttime = System.Currenttimemillis (); fichier file = new File ("C: //users//joke//desktop//demo1.java"); FileInputStream pour (FileinPuttream = new FileInputStream (Fichier); 0;3. BYTE [] Buffer (ne peut lire que le nombre spécifié d'octets et ne peut pas lire un fichier complet)
octet [] bt = nouveau octet [1024]; int count = fileInputStream.read (bt); System.out.println (nouvelle chaîne (bt, 0, count));
//Method 3 create a buffer (can only read the specified size, not read a complete file) public static void test3() throws IOException{File file = new File("C://Users//joke//Desktop//Demo1.java");FileInputStream fileInputStream = new FileInputStream(file);//Create a buffer to speed up reading of data, and determine the byte size to être lu byte [] bt = new byte [1024]; // read () lire byte int count = fileInputStream.read (bt); System.out.println (count); // Affiche le nombre d'octets de lecture System.out.println (nouvelle chaîne (bt, 0, count)); // Convertir les octets en chaîne pour afficher FileInputStream.close ();}4. Combinant du tampon et de la boucle. Le tampon est généralement réglé sur un multiple de 1024. Plus l'ensemble de tampon est grand, plus l'efficacité de lecture est grande.
octet [] bt = nouveau octet [1024]; int count = 0; while ((count = fileInputStream.read (bt))! = -1) {System.out.println (new String (bt, 0, count)); } // Méthode Quatre boucles sont combinées avec du tampon (haute efficacité) public static void test4 () lance ioException {// Efficacité de test by time starttime = system.currenttimemillis (); file file = new File ("c: //users//joke//desktop//demo1.java"); fileinputStream fileinputStstream = newputStream (le fichier); fileinputStream fileinputStStream = New Filestream "); FileInputStream FileinPutStream = New); Le tampon est généralement réglé sur des multiples de 1024. Théoriquement, plus l'ensemble de tampon est élevé, plus l'octet d'efficacité de lecture est élevé [] bt = nouvel octet [1024]; int count = 0; // lors de la lecture Renvoie -1, il est prouvé que pendant ((count) FileInputStream.Read (bt))! = -1) System.out.println (new String (bt, 0, count));} fileInputStream.close (); Long EndTime = System.currentTimemillis (); System.out.println ("Temps pris pour lire le fichier:" + (StarteTtime de fin));}Momo a dit:
Dans ce qui précède, en comparant les deuxième et quatrième méthodes, vous constaterez que l'efficacité de la méthode 4 est relativement élevée, donc les quatre méthodes recommandées sont utilisées
Ici, nous jetons directement des exceptions, en plus de lancer, nous pouvons également utiliser
try{ }cater{ }finally{ }
Pour gérer les exceptions
Ce qui précède est l'utilisation de InputString (), le flux d'entrée du flux Java IO qui vous est présenté. J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!