Java: Comment lire un fichier texte

Java 1.5 a introduit la classe Scanner pour gérer les entrées de fichiers et de flux.

Il est utilisé pour obtenir des entiers à partir d'un fichier et ressemblerait à ceci:

List<Integer> integers = new ArrayList<Integer>();
Scanner fileScanner = new Scanner(new File("c:\\file.txt"));
while (fileScanner.hasNextInt()){
   integers.add(fileScanner.nextInt());
}

Vérifiez l'API cependant. Il y a beaucoup plus d'options pour traiter différents types de sources d'entrée, différents délimiteurs et différents types de données.

Cet exemple de code vous montre comment lire un fichier en Java.

import java.io.*;

/**
 * This example code shows you how to read file in Java
 *
 * IN MY CASE RAILWAY IS MY TEXT FILE WHICH I WANT TO DISPLAY YOU CHANGE WITH YOUR   OWN      
 */

 public class ReadFileExample 
 {
    public static void main(String[] args) 
    {
       System.out.println("Reading File from Java code");
       //Name of the file
       String fileName="RAILWAY.txt";
       try{

          //Create object of FileReader
          FileReader inputFile = new FileReader(fileName);

          //Instantiate the BufferedReader Class
          BufferedReader bufferReader = new BufferedReader(inputFile);

          //Variable to hold the one line data
          String line;

          // Read file line by line and print on the console
          while ((line = bufferReader.readLine()) != null)   {
            System.out.println(line);
          }
          //Close the buffer reader
          bufferReader.close();
       }catch(Exception e){
          System.out.println("Error while reading file line by line:" + e.getMessage());                      
       }

     }
  }

Regardez cet exemple et essayez de faire le vôtre:

import java.io.*;

public class ReadFile {

    public static void main(String[] args){
        String string = "";
        String file = "textFile.txt";

        // Reading
        try{
            InputStream ips = new FileInputStream(file);
            InputStreamReader ipsr = new InputStreamReader(ips);
            BufferedReader br = new BufferedReader(ipsr);
            String line;
            while ((line = br.readLine()) != null){
                System.out.println(line);
                string += line + "\n";
            }
            br.close();
        }
        catch (Exception e){
            System.out.println(e.toString());
        }

        // Writing
        try {
            FileWriter fw = new FileWriter (file);
            BufferedWriter bw = new BufferedWriter (fw);
            PrintWriter fileOut = new PrintWriter (bw);
                fileOut.println (string+"\n test of read and write !!");
            fileOut.close();
            System.out.println("the file " + file + " is created!");
        }
        catch (Exception e){
            System.out.println(e.toString());
        }
    }
}

Juste pour le plaisir, voici ce que je ferais probablement dans un vrai projet, où j'utilise déjà toutes mes bibliothèques préférées (dans ce cas Goyave, anciennement connu sous le nom de Google Collections).

String text = Files.toString(new File("textfile.txt"), Charsets.UTF_8);
List<Integer> list = Lists.newArrayList();
for (String s : text.split("\\s")) {
    list.add(Integer.valueOf(s));
}

Avantage: Pas beaucoup de code propre à maintenir (contrairement à par exemple this). Edit : Bien qu'il soit intéressant de noter que dans ce cas la solution de scanner de tschaible n'a plus de code!

Inconvénient: vous ne voudrez évidemment pas ajouter de nouveaux dépendances de bibliothèque juste pour cela. ^{(Là encore, vous seriez idiot de ne pas utiliser la goyave dans vos projets. ;-)}

Utilisez Apache Commons (IO et Lang) pour des choses simples/communes comme celle-ci.

Importations:

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.ArrayUtils;

Code:

String contents = FileUtils.readFileToString(new File("path/to/your/file.txt"));
String[] array = ArrayUtils.toArray(contents.split(" "));

Terminé.

Utilisation de Java 7 pour lire des fichiers avec NIO.2

Importer ces paquets:

import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

C'est le processus pour lire un fichier:

Path file = Paths.get("C:\\Java\\file.txt");

if(Files.exists(file) && Files.isReadable(file)) {

    try {
        // File reader
        BufferedReader reader = Files.newBufferedReader(file, Charset.defaultCharset());

        String line;
        // read each line
        while((line = reader.readLine()) != null) {
            System.out.println(line);
            // tokenize each number
            StringTokenizer tokenizer = new StringTokenizer(line, " ");
            while (tokenizer.hasMoreElements()) {
                // parse each integer in file
                int element = Integer.parseInt(tokenizer.nextToken());
            }
        }
        reader.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Pour lire toutes les lignes d'un fichier à la fois:

Path file = Paths.get("C:\\Java\\file.txt");
List<String> lines = Files.readAllLines(file, StandardCharsets.UTF_8);

Toutes les réponses fournies jusqu'à présent impliquent la lecture du fichier ligne par ligne, la prise de la ligne en tant que String, puis le traitement du String.

Il ne fait aucun doute que c'est l'approche la plus facile à comprendre, et si le fichier est assez court (disons, des dizaines de milliers de lignes), il sera également acceptable en termes d'efficacité. , Mais si le fichier est long, c'est un moyen inefficace de le faire, pour deux raisons:

1. Chaque caractère est traité deux fois, une fois dans construire le String, et une fois en le traitant.
2. Le garbage collector ne sera pas votre ami s'il y a beaucoup de lignes dans le fichier. Vous construisez un nouveau String pour chaque ligne, puis vous le jetez lorsque vous passez à la ligne suivante. Le garbage collector devra éventuellement disposer de tous ces String objets que vous ne voulez plus. Quelqu'un a eu à nettoyer après vous.

Si vous vous souciez de la vitesse, vous êtes beaucoup mieux de lire un bloc de données et ensuite le traitement octet par octet plutôt que ligne par ligne. Chaque fois que vous arrivez à la fin d'un nombre, vous l'ajoutez au List que vous construisez.

Il sortira quelque chose comme ceci:

private List<Integer> readIntegers(File file) throws IOException {
    List<Integer> result = new ArrayList<>();
    RandomAccessFile raf = new RandomAccessFile(file, "r");
    byte buf[] = new byte[16 * 1024];
    final FileChannel ch = raf.getChannel();
    int fileLength = (int) ch.size();
    final MappedByteBuffer mb = ch.map(FileChannel.MapMode.READ_ONLY, 0,
            fileLength);
    int acc = 0;
    while (mb.hasRemaining()) {
        int len = Math.min(mb.remaining(), buf.length);
        mb.get(buf, 0, len);
        for (int i = 0; i < len; i++)
            if ((buf[i] >= 48) && (buf[i] <= 57))
                acc = acc * 10 + buf[i] - 48;
            else {
                result.add(acc);
                acc = 0;
            }
    }
    ch.close();
    raf.close();
    return result;
}

Le code ci-dessus suppose qu'il s'agit d'ASCII (bien qu'il puisse être facilement modifié pour d'autres encodages), et que tout ce qui n'est pas un chiffre (en particulier, un espace ou une nouvelle ligne) représente une frontière entre les chiffres. Il suppose également que le fichier se termine par un chiffre (dans la pratique, que l' la dernière ligne se termine par un retour à la ligne), bien que, encore une fois, il pourrait être modifié pour traiter le cas où ce n'est pas le cas.

C'est beaucoup, beaucoup plus rapide que n'importe laquelle des approches basées sur String également données comme réponses à cette question. Il y a une enquête détaillée sur une question très similaire dans cette question. Vous verrez là qu'il y a la possibilité de l'améliorer encore plus si vous voulez descendre la ligne multithread.

Lisez le fichier puis faites ce que vous voulez java8 Fichier.lignes(les Chemins d'accès.obtenir("c://lines.txt")).recueillir (Collectionneurs.toList());