Lecture d'un fichier texte en Java


Answers

Ma façon préférée de lire un petit fichier est d'utiliser un BufferedReader et un StringBuilder. C'est très simple et précis (mais pas particulièrement efficace, mais assez bon pour la plupart des cas):

BufferedReader br = new BufferedReader(new FileReader("file.txt"));
try {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
} finally {
    br.close();
}

Certains ont fait remarquer que, après Java 7, vous devriez utiliser les fonctions try-with-resources (c'est try-with-resources dire fermeture automatique):

try(BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    StringBuilder sb = new StringBuilder();
    String line = br.readLine();

    while (line != null) {
        sb.append(line);
        sb.append(System.lineSeparator());
        line = br.readLine();
    }
    String everything = sb.toString();
}

Quand je lis des chaînes comme celle-ci, je veux généralement faire un peu de manipulation de chaînes par ligne, alors je vais pour cette implémentation.

Cependant, si je veux juste lire un fichier dans une chaîne, j'utilise toujours Apache Commons IO avec la méthode class IOUtils.toString (). Vous pouvez jeter un oeil à la source ici:

http://www.docjar.com/html/api/org/apache/commons/io/IOUtils.java.html

FileInputStream inputStream = new FileInputStream("foo.txt");
try {
    String everything = IOUtils.toString(inputStream);
} finally {
    inputStream.close();
}

Et encore plus simple avec Java 7:

try(FileInputStream inputStream = new FileInputStream("foo.txt")) {     
    String everything = IOUtils.toString(inputStream);
    // do something with everything string
}
Question

Il semble qu'il existe différentes façons de lire et d'écrire des données de fichiers en Java.

Je veux lire les données ASCII d'un fichier. Quelles sont les manières possibles et leurs différences?




Voici une solution simple:

String content;

content = new String(Files.readAllBytes(Paths.get("sample.txt")));



Les méthodes dans org.apache.commons.io.FileUtils peuvent également être très utiles, par exemple:

/**
 * Reads the contents of a file line by line to a List
 * of Strings using the default encoding for the VM.
 */
static List readLines(File file)



Ce n'est peut-être pas la réponse exacte à la question. C'est juste une autre façon de lire un fichier où vous ne spécifiez pas explicitement le chemin vers votre fichier dans votre code Java et à la place, vous le lisez comme un argument de ligne de commande.

Avec le code suivant,

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class InputReader{

    public static void main(String[] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s="";
        while((s=br.readLine())!=null){
            System.out.println(s);
        }
    }
}

allez-y et lancez-le avec:

java InputReader < input.txt

Cela lirait le contenu du input.txt et l'imprimerait sur votre console.

Vous pouvez également créer votre System.out.println() pour écrire dans un fichier spécifique via la ligne de commande comme suit:

java InputReader < input.txt > output.txt

Cela lirait de input.txt et écrirait à output.txt .




Ci-dessous est un one-liner de le faire de la manière Java 8. En supposant que le fichier text.txt trouve à la racine du répertoire du projet de l'Eclipse.

Files.lines(Paths.get("text.txt")).collect(Collectors.toList());



Vous pouvez utiliser readAllLines et la méthode join pour obtenir le contenu entier d'un fichier sur une ligne:

String str = String.join("\n",Files.readAllLines(Paths.get("e:\\text.txt")));

Il utilise par défaut le codage UTF-8 qui lit correctement les données ASCII.

Vous pouvez également utiliser readAllBytes:

String str = new String(Files.readAllBytes(Paths.get("e:\\text.txt")), StandardCharsets.UTF_8);

Je pense que readAllBytes est plus rapide et plus précis, car il ne remplace pas la nouvelle ligne par \n et aussi la nouvelle ligne peut être \r\n . C'est en fonction de vos besoins que l'on est apte.




Voici les trois méthodes de travail et testées:

Utilisation de BufferedReader

package io;
import java.io.*;
public class ReadFromFile2 {
    public static void main(String[] args)throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        BufferedReader br = new BufferedReader(new FileReader(file));
        String st;
        while((st=br.readLine()) != null){
            System.out.println(st);
        }
    }
}

Utilisation du Scanner

package io;

import java.io.File;
import java.util.Scanner;

public class ReadFromFileUsingScanner {
    public static void main(String[] args) throws Exception {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        while(sc.hasNextLine()){
            System.out.println(sc.nextLine());
        }
    }
}

Utiliser FileReader

package io;
import java.io.*;
public class ReadingFromFile {

    public static void main(String[] args) throws Exception {
        FileReader fr = new FileReader("C:\\Users\\pankaj\\Desktop\\test.java");
        int i;
        while ((i=fr.read()) != -1){
            System.out.print((char) i);
        }
    }
}

Lire le fichier entier sans boucle en utilisant la classe Scanner

package io;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ReadingEntireFileWithoutLoop {

    public static void main(String[] args) throws FileNotFoundException {
        File file = new File("C:\\Users\\pankaj\\Desktop\\test.java");
        Scanner sc = new Scanner(file);
        sc.useDelimiter("\\Z");
        System.out.println(sc.next());
    }
}



J'ai documenté 15 façons de lire un fichier en Java , puis les ai testés pour la vitesse avec différentes tailles de fichiers - de 1 Ko à 1 Go et voici les trois principales façons de le faire:

  1. java.nio.file.Files.readAllBytes()

    Testé pour fonctionner dans Java 7, 8 et 9.

    import java.io.File;
    import java.io.IOException;
    import java.nio.file.Files;
    
    public class ReadFile_Files_ReadAllBytes {
      public static void main(String [] pArgs) throws IOException {
        String fileName = "c:\\temp\\sample-10KB.txt";
        File file = new File(fileName);
    
        byte [] fileBytes = Files.readAllBytes(file.toPath());
        char singleChar;
        for(byte b : fileBytes) {
          singleChar = (char) b;
          System.out.print(singleChar);
        }
      }
    }
    
  2. java.io.BufferedReader.readLine()

    Testé pour fonctionner en Java 7, 8, 9.

    import java.io.BufferedReader;
    import java.io.FileReader;
    import java.io.IOException;
    
    public class ReadFile_BufferedReader_ReadLine {
      public static void main(String [] args) throws IOException {
        String fileName = "c:\\temp\\sample-10KB.txt";
        FileReader fileReader = new FileReader(fileName);
    
        try (BufferedReader bufferedReader = new BufferedReader(fileReader)) {
          String line;
          while((line = bufferedReader.readLine()) != null) {
            System.out.println(line);
          }
        }
      }
    }
    
  3. java.nio.file.Files.lines()

    Cela a été testé pour fonctionner dans Java 8 et 9 mais ne fonctionnera pas dans Java 7 en raison de l'exigence d'expression lambda.

    import java.io.File;
    import java.io.IOException;
    import java.nio.file.Files;
    import java.util.stream.Stream;
    
    public class ReadFile_Files_Lines {
      public static void main(String[] pArgs) throws IOException {
        String fileName = "c:\\temp\\sample-10KB.txt";
        File file = new File(fileName);
    
        try (Stream linesStream = Files.lines(file.toPath())) {
          linesStream.forEach(line -> {
            System.out.println(line);
          });
        }
      }
    }
    



Guava fournit un one-liner pour ceci:

import com.google.common.base.Charsets;
import com.google.common.io.Files;

String contents = Files.toString(filePath, Charsets.UTF_8);



Je ne le vois pas encore mentionné dans les autres réponses jusqu'à présent. Mais si "Best" signifie vitesse, alors la nouvelle E / S Java (NIO) pourrait fournir la pré-performance la plus rapide, mais pas toujours la plus facile à comprendre pour quelqu'un qui apprend.

http://download.oracle.com/javase/tutorial/essential/io/file.html




C'est fondamentalement la même chose que la réponse de Jesus Ramos, sauf avec File au lieu de FileReader plus itération pour parcourir le contenu du fichier.

Scanner in = new Scanner(new File("filename.txt"));

while (in.hasNext()) { // Iterates each line in the file
    String line = in.nextLine();
    // Do something with line
}

in.close(); // Don't forget to close resource leaks

... jette FileNotFoundException




Links