Java: Comment lire un fichier texte

Java 1.5 a introduit la classe Scanner pour le traitement des entrées à partir du fichier et des flux.

il est utilisé pour obtenir des entiers à partir d'un fichier et ressemblerait à quelque chose comme 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 existe de nombreuses autres options pour traiter différents types de sources d'entrée, de délimiteurs différents et de types de données différents.

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 votre propre:

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 Guava ", anciennement connu sous le nom 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: peu de code propre à maintenir (contraste avec par exemple ce ). modifier : bien Qu'il soit intéressant de noter que dans ce cas la solution Scanner de tschaible n'a plus de code!

inconvénient: Vous pouvez évidemment ne pas vouloir ajouter de nouvelles dépendances de bibliothèque juste pour cela. ^{(encore une fois, vous seriez bête de ne pas utiliser la goyave dans vos projets. ;- )}

Utiliser Apache Commons (IO et Lang) pour une simple/commune des choses comme ça.

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(" "));

fait.

utilisant Java 7 pour lire des fichiers avec NIO.2

importer ces colis:

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 données jusqu'à présent impliquent la lecture du fichier ligne par ligne, en prenant la ligne comme un 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 la construction du String , et une fois dans le traitement.
2. le ramasseur d'ordures ne sera pas votre ami s'il y a beaucoup de lignes dans le dossier. Vous construisez un nouveau String pour chaque ligne, puis vous le jetez lorsque vous passez à la ligne suivante. Le ramasseur d'ordures devra éventuellement se débarrasser de tous ces objets String que vous ne voulez plus. Quelqu'un a eu à nettoyer après vous.

si vous vous souciez de la vitesse, il est beaucoup mieux de lire un bloc de données et de le traiter ensuite octet par octet plutôt que ligne par ligne. Chaque fois que vous arrivez à la fin d'un numéro, 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 non-chiffre (en pratique, que la dernière ligne se termine par une nouvelle ligne), bien que, encore une fois, il pourrait être modifié pour traiter le cas où il ne se termine pas.

Il est beaucoup plus rapide que l'un des String approches fondées aussi étant donné que les réponses à cette question. Il y a une enquête détaillée d'un question très similaire dans cette question . Vous verrez là qu'il y a la possibilité de l'améliorer encore si vous voulez descendre la ligne multi-threaded.

lire le dossier et puis faire ce que vous voulez java8 Fichier.lignes(les Chemins d'accès.get("c://lines.txt")).recueillir des(Collectionneurs.toList());