Gestion des fichiers java

Question

Tout en essayant de faire une opération avec les fichiers du code va comme ceci,

File file=new File("aaa.txt"); 

J'ai vu dans un programme BufferedReader et InputStreamReader ont également été inclus pouvez-vous expliquer cela par un exemple simple? J'ai lu dans de nombreux sites sur la manipulation des fichiers mais encore son confus !!!!

Answer 1

La classe File est essentiellement un descripteur de fichier qui vous permet d'obtenir un handle sur le fichier, mais ne possède pas en soi de méthodes pour lire les informations du fichier.

C'est là que le InputStreamReader entre en jeu. Un InputStreamReader (et plus facilement sa sous-classe la FileReader) fera la lecture pour vous (il y a d'autres façons de le faire, mais c'est l'un des plus faciles).

Le BufferedReader encapsulera le InputStreamReader et lira le fichier dans un tampon (plutôt que de simplement convertir et renvoyer les octets après chaque invocation de lecture), ce qui vous permettra de lire plus facilement les données.

Answer 2

Jetez un oeil à cette tutorial de base

Fondamentalement, le BufferedReader est de lire les informations de fichier. Il y a plusieurs façons de le faire et dépend vraiment de vos besoins.

Answer 3

public void printFileContentsToConsole(final String aFileName) { 
//Make a new file. 
File file = new File(aFileName); 

//Declare the reader outside the scope so we can use it 
//in the finally block. 
BufferedReader reader = null; 

try { 
    reader = new BufferedReader(new FileReader(file)); 
    String line; 

    //Read one line at a time, printing it. 
    while ((line = reader.readLine()) != null) { 
    System.out.println(line); 
    } 
} catch (IOException e) { 
    e.printStackTrace(); 
} catch (Exception e) { 
    e.printStackTrace(); 
} finally { 
    try { 
    //Try to close it, this might throw an exception anyway. 
    reader.close(); 
    } catch (Exception ex) { 
    ex.printStackTrace(); 
    } 
} 
} 

De toute évidence, avoir un regard sur les BufferedReader et FileReader API répondra à beaucoup de vos questions au sujet de ces classes particulières.

Pour clarifier pourquoi vous voudriez utiliser un BufferedReader, le point est de lire efficacement dans un fichier, ligne par ligne.

Answer 4

Voici comment je l'ai lu un fichier à partir du disque:

Notez que tout le code doit être placé dans une instruction try/catch, en cas de FileNotFoundException par exemple.

try 
{ 
    //You first have to create a reader that will be used to access the file. 
    //You create the BufferedReader from a FileReader, and you only need to specify 
    //the address of the file on your disk. 
    BufferedReader br = new BufferedReader(new FileReader("fileURL")); 

    String s; 

    //The BufferedReader has a method "readLine" that reads the file line by line 
    //When the reader reaches the end of the file, the method readLine returns null, 
    //so you can control if there is some data remaining or not. 
    while((s = br.readLine()) != null) 
    { 
      System.out.println(s); 
    } 

    //Don't forget to close the reader when the process is over. 
    br.close(); 
} 
catch(Exception e) 
{ 
    // Do some stuff 
} 

que je me souvienne, les classes BufferedReader un FileReader se trouvent dans le paquet java.io; À mon avis, c'est la façon la plus simple de lire un fichier en Java. Si vous avez besoin de savoir comment écrire un fichier, le processus est presque le même, donc je peux aussi vous donner quelques conseils.

Espérons que cela aide.

Answer 5

Fondamentalement, la classe java.io.File représente un fichier dans le système de fichiers, mais ne contient pas des méthodes pour les manipuler (autres que les créer ou les supprimer)

Lorsque vous devez travailler avec eux, vous utilisez d'autres classes du paquet java.io, BufferefReader et InputStreamReader sont parmi eux, mais thare sont d'autres comme FileInputStream. Selon l'opération que vous voulez effectuer, vous pouvez utiliser un lecteur ou un flux (les classes se terminant par "Reader" ou "Writer" sont pour le contenu du texte, les classes se terminant par "Stream" sont pour le contenu binaire, mais bien sûr , vous pouvez toujours lire/écrire du texte en binaire).

La plupart du temps, vous devez "chaîner" quelques-unes de ces classes pour effectuer un travail. Il est également important de noter que, la plupart du temps, vous pouvez avoir un code très similaire à écrire sur une socket.

Un exemple naïf pourrait être ceci:

package demo; 
import java.io.BufferedReader; 
import java.io.FileReader; 
import java.io.File; 
import java.io.IOException; 

import java.util.List; 
import java.util.ArrayList; 


public class ReadLines { 
    public static void main(String [] args) throws IOException { 
     File toRead = new File(args[0]); 
     if(toRead.exists()) { 
      List<String> lines = readLines(toRead); 
     } else { 
      System.out.println(toRead.getName() + " doesn't exists"); 
     } 
    } 
    private static List<String> readLines(File fromFile) throws IOException { 
      BufferedReader reader = null; 

      List<String> lines = new ArrayList<String>(); 
      try { 
       reader = new BufferedReader(new FileReader(fromFile)); // chaining 
       String line = null; 
       while((line = reader.readLine()) != null) { 
        lines.add(line); 
       } 
     } finally { 
      // always close the file 
      if(reader != null) try { 
       reader.close(); 
      } catch(IOException ioe) { 
       // it's ok to ignore an exception while closing a file 
      } 
     } 
     return lines; 
     } 
    } 

J'espère que ce code, le rendre plus clair pour vous et compiles ( : PI ne pas un compilateur à la main )

Voir aussi :

http://download.oracle.com/javase/tutorial/essential/io/ http://download.oracle.com/javase/6/docs/api/java/io/package-summary.html http://download.oracle.com/javase/6/docs/api/java/io/Reader.html http://download.oracle.com/javase/6/docs/api/java/io/Writer.html http://download.oracle.com/javase/6/docs/api/java/io/InputStream.html http://download.oracle.com/javase/6/docs/api/java/io/OutputStream.html

Answer 6

Par souci de clarté, pris de la javadoc de InputStreamReader.java

Un InputStreamReader est un pont de octets flux de flux de caractères: Il lit les octets et les décode en caractères à l'aide d'un charset spécifié. [...] Chaque appel de l'une des méthodes read() de InputStreamReader peut provoquer la lecture d'un ou de plusieurs octets à partir du flux d'octets d'entrée sous-jacent. Pour activer la conversion efficace de octets en caractères, plus d'octets peut être lire avant à partir du flux sous-jacent que nécessaire pour satisfaire l'opération de lecture en cours .

Pour une efficacité supérieure, pensez à emballer un InputStreamReader dans un BufferedReader. Par exemple:

BufferedReader dans = nouveau BufferedReader (nouveau InputStreamReader (System.in));