Manière efficace de lire un fichier

Question

comment lire un fichier d'une manière efficace en Java? suggérer des méthodes .. j'ai utilisé BufferedReader, qui est très lent .. suggère des changements?

CODE:

import java.io.*; 
import java.awt.*; 
import javax.swing.*; 
import java.awt.event.*; 
import java.lang.StringBuffer; 

/*The main class file starts here*/ 

class TitleCaseRow10 extends JFrame implements ActionListener,FocusListener 
{ 

// Declare the required variables 

JButton jbFileLoad,jbFileSave,jbCaseChange; 
JLabel jlTitle,jlFileSelect,jlContentDisplay; 
Font myFont; 
JPanel mainPanel,fileOperationPanel,buttonPanel,fileOpenPanel; 
JFrame jframe; 
JTextField jtfFileName; 
JTextArea jtaFileContent,jtaCaseChange; 
JScrollPane jScrPaneContent,jScrPaneCaseChange; 
boolean boolFileOk = false; 
File file; 
String fileName,strFileContent,strBuffer=""; 
JFileChooser fileChooser; 

// Constructor method for TitleCaseRow10 

TitleCaseRow10(String titleName) 
{ 
    super(titleName); 

} 

void createAndShowGUI() 

/* This method is used to create the Graphical User Interface 
    and show it in the screen. 
    This method takes no input parameters 
    nor does it return any value. 
*/ 

{ 

    // create and set up the window 

    jframe = new JFrame(); 
    jframe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
    jframe.setSize(500,600); 

    // create the panels 
    // 1. mainPanel for containing other panels 
    // 2. buttonPanel for containing buttons 
    // 3. fileOpenPanel for containing file choose text filed 
    // and load file button 
    // 4. fileOperationPanel for containing all the file operation objects 

    mainPanel = new JPanel(); 
    buttonPanel = new JPanel(); 
    fileOperationPanel = new JPanel(); 
    fileOpenPanel = new JPanel(); 

    // create a file chooser 
    fileChooser = new JFileChooser(); 

    // create labels and buttons 

    jlTitle = new JLabel("TITLE CASE CHANGER",JLabel.CENTER); 
    jlFileSelect = new JLabel("Enter the filename or click 'load file'"); 
    jlContentDisplay = new JLabel("TEXT DISPLAY AREAS",JLabel.CENTER); 
    jbFileLoad = new JButton("Load File"); 
    jbFileSave = new JButton("Save File"); 
    jbCaseChange = new JButton("Title Case"); 

    //Create text feild, text area and scroll panes 

    jtfFileName = new JTextField(28); 
    jtaFileContent = new JTextArea(30,10); 
    jtaCaseChange = new JTextArea(30,10); 
    jScrPaneContent = new JScrollPane(jtaFileContent); 
    jScrPaneCaseChange = new JScrollPane(jtaCaseChange); 


    // set up the panels 

    fileOperationPanel.setBackground(Color.BLACK); 
    fileOpenPanel.setBackground(Color.BLACK); 
    buttonPanel.setBackground(Color.BLACK); 
    mainPanel.setBackground(Color.BLACK); 
    mainPanel.setLayout(new GridLayout(3,0,15,15)); 
    fileOperationPanel.setLayout(new GridLayout(5,0,5,5)); 
    fileOpenPanel.setLayout(new FlowLayout()); 
    buttonPanel.setLayout(new FlowLayout()); 

    // set up text field, labels and text area 

    // set the font 
    myFont = new Font("Constantia",1,15); 
    jtfFileName.setFont(myFont); 
    jlTitle.setFont(myFont); 
    jlContentDisplay.setFont(myFont); 
    jtaFileContent.setFont(myFont); 
    jtaCaseChange.setFont(myFont); 
    jlFileSelect.setFont(new Font("Arial",0,14)); 

    // set line wrap 
    jtaFileContent.setLineWrap(true); 
    jtaCaseChange.setLineWrap(true); 

    //set foreground and background color 
    jlTitle.setForeground(Color.WHITE); 
    jlContentDisplay.setForeground(Color.WHITE); 
    jlFileSelect.setForeground(Color.WHITE); 
    jtaFileContent.setForeground(Color.LIGHT_GRAY); 
    jtaCaseChange.setForeground(Color.LIGHT_GRAY); 
    jtfFileName.setForeground(Color.LIGHT_GRAY); 
    jtaFileContent.setBackground(Color.DARK_GRAY);  
    jtaCaseChange.setBackground(Color.DARK_GRAY); 
    jtfFileName.setBackground(Color.DARK_GRAY); 

    // Set default text to file content text area 
    jtaFileContent.setText("Type text here"); 

    // set up scroll panes 

    jScrPaneContent.setAutoscrolls(true); 
    jScrPaneCaseChange.setAutoscrolls(true); 
    jScrPaneCaseChange.getHorizontalScrollBar(); 
    jScrPaneCaseChange.getHorizontalScrollBar(); 

    // add the action listeners to buttons 

    jbFileLoad.addActionListener(this); 
    jbFileSave.addActionListener(this); 
    jbCaseChange.addActionListener(this); 
    jtaFileContent.addFocusListener(this); 

    // add all the components 

    jframe.add(mainPanel); 
    fileOpenPanel.add(jtfFileName); 
    fileOpenPanel.add(jbFileLoad); 
    buttonPanel.add(jbCaseChange); 
    buttonPanel.add(jbFileSave); 
    fileOperationPanel.add(jlTitle); 
    fileOperationPanel.add(jlFileSelect); 
    fileOperationPanel.add(fileOpenPanel); 
    fileOperationPanel.add(buttonPanel); 
    fileOperationPanel.add(jlContentDisplay); 
    mainPanel.add(fileOperationPanel); 
    mainPanel.add(jScrPaneContent); 
    mainPanel.add(jScrPaneCaseChange); 

    // set the frame visible 

    jframe.setVisible(true); 

} 

public void actionPerformed(ActionEvent ae) 
{ 
    String command = ae.getActionCommand(); 
    if(command.equals("Load File")) 
    { 
    System.out.println("Load File action"); 
    fileName = ""; 
    int retVal = fileChooser.showOpenDialog(this); 
    System.out.println("open dialog..."); 
    if(retVal==JFileChooser.APPROVE_OPTION) 
    { 
     try 
     { 
     file = fileChooser.getSelectedFile(); 
     fileName = fileChooser.getCurrentDirectory().getPath(); 
     fileName = fileName.concat("\\"+file.getName()); 
     jtfFileName.setText(fileName); 
     boolFileOk=true; 
     jtaFileContent.setText(""); 
     BufferedReader br= new BufferedReader(new FileReader(file),1000000); 
     while((strFileContent = br.readLine())!=null) 
      jtaFileContent.append(strFileContent+"\n"); 
     } 
     catch(Exception e) 
     { 
     System.out.println("Some problem : "+e); 
     } 
    } 

    } 
    if(command.equals("Title Case")) 
    System.out.println("Title Case action"); 
    if(command.equals("Save File")) 
    System.out.println("Save File action"); 

} 

public void focusGained(FocusEvent fe) 
{ 
    System.out.println("Focus Gained"); 
    if(!boolFileOk) 
    jtaFileContent.setText(""); 
} 
public void focusLost(FocusEvent fe) 
{ 

    System.out.println("Focus Lost"); 
} 

/* 

boolean loadFile(ActionEvent ae) 
{ 

    // Check if the filename textfield is really empty 

    if(jtfFileName.getText().trim().equals("")) 

    { 
    fileName = ""; 
    int retVal = fileChooser.showOpenDialog(TitleCaseRow10.this); 
    System.out.println("open dialog..."); 
    if(retVal==JFileChooser.APPROVE_OPTION) 
    { 
     try 
     { 
     file = fileChooser.getSelectedFile(); 
     fileName = fileChooser.getCurrentDirectory().getPath(); 
     fileName = fileName.concat("\\"+file.getName()); 
     jtfFileName.setText(fileName); 
     return true; 
     } 
     catch(Exception e) 
     { 
      System.out.println("Some problem : "+e); 
     } 
    } 
    } 

    return false; 
    // returns false if the filename is empty or 
    // if the file is not opened 
} 

*/ 


//***************************************************************** 

//the main method which creates an 
//instance of the class R10TitleCase 

//****************************************************************** 

public static void main(String args[]) 
{ 
    TitleCaseRow10 caseChanger = new TitleCaseRow10("Title Case"); 
    caseChanger.createAndShowGUI(); 
} 
} 

Answer 1

Définir le terme "efficace". Cela dépend de votre modèle d'accès. BufferedReader va accélérer les choses quand vous lisez un octet (ou quelques octets) à la fois, sinon c'est inutile. Cependant, cela ne devrait pas être «très lent» à moins que vous ne fassiez quelque chose de mal dans votre code ou que vous ayez des attentes irréalistes.

Si vous lisez des fichiers très volumineux, java.nio, speficically FileChannel a de bien meilleures performances que java.io.

Edit: Vous semblez être ajouter le contenu du fichier à un JTextArea (je suppose que ce que jtaFileContent est) une ligne à la fois - qui est ce qui est lent (parce qu'il doit mettre à jour l'interface utilisateur à chaque fois, ce qui implique beaucoup de travail), pas la lecture du fichier. Au lieu de cela, vous devriez lire tout le texte dans un StringBuilder et seulement mettre à jour le JTextArea une fois que vous avez tout. Toutefois, si votre fichier est très volumineux, vous manquerez probablement de mémoire et devrez peut-être rechercher un composant d'interface utilisateur différent qui ne chargera que la partie affichée. il devrait y avoir quelque chose comme ça là-bas.

Answer 2

Etes-vous sûr que c'est effectivement le fichier IO qui est lent? Si vous ajoutez simplement le même nombre de lignes à l'aide d'une chaîne codée en dur, est-ce rapide? Je ne serais pas surpris si c'était l'interface graphique qui vous ralentissait. Par ailleurs, FileReader utilisera le codage par défaut de la plate-forme, ce qui est généralement une mauvaise idée. Utilisez un code et un InputStreamReader avec un codage spécifique. (Alors enveloppez-le dans un BufferedReader bien sûr.) Vous devriez également essayer/finalement de fermer le lecteur à la fin.

Answer 3

Le problème est que vous ajoutez directement dans jtaFileContent. Essayez de lire dans un StringBuilder puis appeler jtaFileContent.setText()

StringBuilder sb = new StringBuilder(100); 
for(Scanner sc = new Scanner(new FileReader(fileName)); sc.hasNext();) 
    sb.append(sc.nextLine()); 

jtaFileContent.setText(sb.toString()); 

Answer 4

est ici quelques méthodes utiles. Entre ces trois méthodes, vous pouvez lire un fichier ou une ressource dans une chaîne. Je les utilise tout le temps. J'espère que vous les trouverez utiles:

/** 
* Takes the file and returns it in a string 
* 
* @param location on the disc 
* @return the file in string form 
* @throws IOException 
*/ 
public static String fileToString(String location) throws IOException { 
    FileReader fr = new FileReader(new File(location)); 
    return readerToString(fr); 
} 

/** 
* Takes the given resource (based on the given class) and returns that as a string. 
* 
* @param location relative to the given class (for example "/resources/textFile.txt") 
* @param c the class the location is relative to 
* @return the file in string form 
* @throws IOException 
*/ 
public static String resourceToString(String location, Class c) throws IOException { 
    InputStream is = c.getResourceAsStream(location); 
    InputStreamReader r = new InputStreamReader(is); 
    return readerToString(r); 
} 

/** 
* Returns all the lines in the scanner's stream as a String 
* 
* @param r the InputStreamReader to read 
* @return the InputStreamReader in String form 
* @throws IOException 
*/ 
public static String readerToString(InputStreamReader r) throws IOException { 
    StringWriter sw = new StringWriter(); 
    char[] buf = new char[1024]; 
    int len; 
    while ((len = r.read(buf)) > 0) { 
    sw.write(buf, 0, len); 
    } 
    r.close(); 
    sw.close(); 
    return sw.toString(); 
}