Lecture d'un fichier texte brut en Java

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 au point (bien que 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 souligné qu'après Java 7, vous devriez utiliser les fonctionnalités try-with-resources (c'est-à-dire la 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 une gestion de chaîne par ligne de toute façon, alors je vais pour cette implémentation.

Bien que si je vous voulez simplement lire un fichier dans une chaîne, j'utilise toujours Apache Commons IO avec la classe IOUtils.la méthode toString (). Vous pouvez consulter 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
}

Le moyen le plus simple est d'utiliser la classe Scanner en Java et l'objet FileReader. Exemple simple:

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

Scanner a plusieurs méthodes de lecture en chaînes, nombres, etc... Vous pouvez rechercher plus d'informations à ce sujet sur la page de documentation Java.

Par exemple, lire tout le contenu dans un String:

StringBuilder sb = new StringBuilder();
while(in.hasNext()) {
    sb.append(in.next());
}
in.close();
outString = sb.toString();

Aussi, si vous avez besoin d'un codage spécifique, vous pouvez utiliser ce lieu de FileReader:

new InputStreamReader(new FileInputStream(fileUtf8), StandardCharsets.UTF_8)

Voici une solution simple:

String content;

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

Voici une autre façon de le faire sans utiliser de bibliothèques externes:

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public String readFile(String filename)
{
    String content = null;
    File file = new File(filename); // For example, foo.txt
    FileReader reader = null;
    try {
        reader = new FileReader(file);
        char[] chars = new char[(int) file.length()];
        reader.read(chars);
        content = new String(chars);
        reader.close();
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(reader != null){
            reader.close();
        }
    }
    return content;
}

Je devais comparer les différentes façons. Je vais commenter mes conclusions, mais, en bref, le moyen le plus rapide est d'utiliser un vieux BufferedInputStream sur un FileInputStream. Si de nombreux fichiers doivent être lus, trois threads réduiront le temps d'exécution total à environ la moitié, mais l'ajout de plus de threads dégradera progressivement les performances jusqu'à ce que cela prenne trois fois plus de temps pour terminer avec vingt threads qu'avec un seul thread.

L'hypothèse est que vous devez lire un fichier et faire quelque chose de significatif avec son contenu. Dans les exemples, voici la lecture de lignes à partir d'un journal et compter celles qui contiennent des valeurs qui dépassent un certain seuil. Je suppose donc que le Java 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";")) à une ligne n'est pas une option.

J'ai testé sur Java 1.8, Windows 7 et les disques SSD et HDD.

J'ai écrit six implémentations différentes:

RawParse : Utilisez BufferedInputStream sur un FileInputStream, puis coupez les lignes lisant octet par octet. Cela a surpassé tout autre approche à un seul thread, mais cela peut être très gênant pour les fichiers non ASCII.

LineReaderParse : Utilisez un BufferedReader sur un FileReader, lisez ligne par ligne, divisez les lignes en appelant String.Split(). C'est environ 20% plus lent que rawParse.

LineReaderParseParallel: C'est la même chose que lineReaderParse, mais il utilise plusieurs threads. C'est l'option la plus rapide dans tous les cas.

NioFilesParse : Utiliser Java.nio.fichier.Fichier.lignes()

NioAsyncParse : Utilisez un AsynchronousFileChannel avec un gestionnaire d'achèvement et un pool de threads.

NioMemoryMappedParse: Utilisez un fichier mappé en mémoire. C'est vraiment une mauvaise idée qui donne des temps d'exécution au moins trois fois plus longs que toute autre implémentation.

Ce sont les temps moyens de lecture de 204 fichiers de 4 Mo chacun sur un lecteur quad-core i7 et SSD. Les fichiers sont générés à la volée pour éviter le disque cache.

rawParse                11.10 sec
lineReaderParse         13.86 sec
lineReaderParseParallel  6.00 sec
nioFilesParse           13.52 sec
nioAsyncParse           16.06 sec
nioMemoryMappedParse    37.68 sec

J'ai trouvé une différence plus petite que prévu entre l'exécution sur un SSD ou un disque DUR étant le SSD environ 15% plus rapide. Cela peut être dû au fait que les fichiers sont générés sur un disque dur non fragmenté et qu'ils sont lus séquentiellement, donc le lecteur tournant peut fonctionner presque comme un SSD.

J'ai été surpris par les faibles performances de l'implémentation nioAsyncParse. Soit j'ai implémenté quelque chose de la mauvaise manière, soit l'implémentation multi-thread en utilisant NIO et un gestionnaire d'achèvement effectue la même chose (ou même pire) qu'une implémentation à un seul thread avec le java.io API. De plus, l'analyse asynchrone avec un CompletionHandler est beaucoup plus longue en lignes de code et difficile à implémenter correctement qu'une implémentation directe sur les anciens flux.

Maintenant les six implémentations suivies d'une classe les contenant toutes plus une méthode main() paramétrable qui permet de jouer avec le nombre de fichiers, la taille du fichier et le degré de concurrence. Notez que l' la taille des fichiers varie plus moins 20%. C'est pour éviter tout effet dû à tous les fichiers de exactement de la même taille.

RawParse

public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    overrunCount = 0;
    final int dl = (int) ';';
    StringBuffer lineBuffer = new StringBuffer(1024);
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileInputStream fin = new FileInputStream(fl);
        BufferedInputStream bin = new BufferedInputStream(fin);
        int character;
        while((character=bin.read())!=-1) {
            if (character==dl) {

                // Here is where something is done with each line
                doSomethingWithRawLine(lineBuffer.toString());
                lineBuffer.setLength(0);
            }
            else {
                lineBuffer.append((char) character);
            }
        }
        bin.close();
        fin.close();
    }
}

public final void doSomethingWithRawLine(String line) throws ParseException {
    // What to do for each line
    int fieldNumber = 0;
    final int len = line.length();
    StringBuffer fieldBuffer = new StringBuffer(256);
    for (int charPos=0; charPos<len; charPos++) {
        char c = line.charAt(charPos);
        if (c==DL0) {
            String fieldValue = fieldBuffer.toString();
            if (fieldValue.length()>0) {
                switch (fieldNumber) {
                    case 0:
                        Date dt = fmt.parse(fieldValue);
                        fieldNumber++;
                        break;
                    case 1:
                        double d = Double.parseDouble(fieldValue);
                        fieldNumber++;
                        break;
                    case 2:
                        int t = Integer.parseInt(fieldValue);
                        fieldNumber++;
                        break;
                    case 3:
                        if (fieldValue.equals("overrun"))
                            overrunCount++;
                        break;
                }
            }
            fieldBuffer.setLength(0);
        }
        else {
            fieldBuffer.append(c);
        }
    }
}

LineReaderParse

public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    String line;
    for (int f=0; f<numberOfFiles; f++) {
        File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        FileReader frd = new FileReader(fl);
        BufferedReader brd = new BufferedReader(frd);

        while ((line=brd.readLine())!=null)
            doSomethingWithLine(line);
        brd.close();
        frd.close();
    }
}

public final void doSomethingWithLine(String line) throws ParseException {
    // Example of what to do for each line
    String[] fields = line.split(";");
    Date dt = fmt.parse(fields[0]);
    double d = Double.parseDouble(fields[1]);
    int t = Integer.parseInt(fields[2]);
    if (fields[3].equals("overrun"))
        overrunCount++;
}

LineReaderParseParallel

public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
    Thread[] pool = new Thread[degreeOfParalelism];
    int batchSize = numberOfFiles / degreeOfParalelism;
    for (int b=0; b<degreeOfParalelism; b++) {
        pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
        pool[b].start();
    }
    for (int b=0; b<degreeOfParalelism; b++)
        pool[b].join();
}

class LineReaderParseThread extends Thread {

    private String targetDir;
    private int fileFrom;
    private int fileTo;
    private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private int overrunCounter = 0;

    public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
        this.targetDir = targetDir;
        this.fileFrom = fileFrom;
        this.fileTo = fileTo;
    }

    private void doSomethingWithTheLine(String line) throws ParseException {
        String[] fields = line.split(DL);
        Date dt = fmt.parse(fields[0]);
        double d = Double.parseDouble(fields[1]);
        int t = Integer.parseInt(fields[2]);
        if (fields[3].equals("overrun"))
            overrunCounter++;
    }

    @Override
    public void run() {
        String line;
        for (int f=fileFrom; f<fileTo; f++) {
            File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
            try {
            FileReader frd = new FileReader(fl);
            BufferedReader brd = new BufferedReader(frd);
            while ((line=brd.readLine())!=null) {
                doSomethingWithTheLine(line);
            }
            brd.close();
            frd.close();
            } catch (IOException | ParseException ioe) { }
        }
    }
}

NioFilesParse

public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
    for (int f=0; f<numberOfFiles; f++) {
        Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
        Consumer<String> action = new LineConsumer();
        Stream<String> lines = Files.lines(ph);
        lines.forEach(action);
        lines.close();
    }
}


class LineConsumer implements Consumer<String> {

    @Override
    public void accept(String line) {

        // What to do for each line
        String[] fields = line.split(DL);
        if (fields.length>1) {
            try {
                Date dt = fmt.parse(fields[0]);
            }
            catch (ParseException e) {
            }
            double d = Double.parseDouble(fields[1]);
            int t = Integer.parseInt(fields[2]);
            if (fields[3].equals("overrun"))
                overrunCount++;
        }
    }
}

NioAsyncParse

public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
    ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
    ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();

    for (int b=0; b<numberOfThreads; b++)
        byteBuffers.add(ByteBuffer.allocate(bufferSize));

    for (int f=0; f<numberOfFiles; f++) {
        consumerThreads.acquire();
        String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
        AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
        BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
        channel.read(consumer.buffer(), 0l, channel, consumer);
    }
    consumerThreads.acquire(numberOfThreads);
}


class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {

        private ConcurrentLinkedQueue<ByteBuffer> buffers;
        private ByteBuffer bytes;
        private String file;
        private StringBuffer chars;
        private int limit;
        private long position;
        private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
            buffers = byteBuffers;
            bytes = buffers.poll();
            if (bytes==null)
                bytes = ByteBuffer.allocate(bufferSize);

            file = fileName;
            chars = new StringBuffer(bufferSize);
            frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            limit = bufferSize;
            position = 0l;
        }

        public ByteBuffer buffer() {
            return bytes;
        }

        @Override
        public synchronized void completed(Integer result, AsynchronousFileChannel channel) {

            if (result!=-1) {
                bytes.flip();
                final int len = bytes.limit();
                int i = 0;
                try {
                    for (i = 0; i < len; i++) {
                        byte by = bytes.get();
                        if (by=='\n') {
                            // ***
                            // The code used to process the line goes here
                            chars.setLength(0);
                        }
                        else {
                                chars.append((char) by);
                        }
                    }
                }
                catch (Exception x) {
                    System.out.println(
                        "Caught exception " + x.getClass().getName() + " " + x.getMessage() +
                        " i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
                        ", position="+String.valueOf(position));
                }

                if (len==limit) {
                    bytes.clear();
                    position += len;
                    channel.read(bytes, position, channel, this);
                }
                else {
                    try {
                        channel.close();
                    }
                    catch (IOException e) {
                    }
                    consumerThreads.release();
                    bytes.clear();
                    buffers.add(bytes);
                }
            }
            else {
                try {
                    channel.close();
                }
                catch (IOException e) {
                }
                consumerThreads.release();
                bytes.clear();
                buffers.add(bytes);
            }
        }

        @Override
        public void failed(Throwable e, AsynchronousFileChannel channel) {
        }
};

EXÉCUTION COMPLÈTE DE TOUS CAS

Https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java

Les méthodes au sein de org.apache.commons.io.FileUtils peut également être très pratique, 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)

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

En utilisant 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);
        }
    }
}

En utilisant 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());
        }
    }
}

En utilisant 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());
    }
}

Que voulez-vous faire avec le texte? Le fichier est-il assez petit pour tenir en mémoire? J'essaierais de trouver le moyen le plus simple de gérer le fichier pour vos besoins. La bibliothèque FileUtils est très maniable pour cela.

for(String line: FileUtils.readLines("my-text-file"))
    System.out.println(line);

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

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

Utilisation de BufferedReader:

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

BufferedReader br;
try {
    br = new BufferedReader(new FileReader("/fileToRead.txt"));
    try {
        String x;
        while ( (x = br.readLine()) != null ) {
            // Printing out each line in the file
            System.out.println(x);
        }
    }
    catch (IOException e) {
        e.printStackTrace();
    }
}
catch (FileNotFoundException e) {
    System.out.println(e);
    e.printStackTrace();
}

C'est fondamentalement exactement la même chose que la réponse de Jesus Ramos, sauf avec Fileau 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

Probablement pas aussi rapide qu'avec les E/S tamponnées, mais assez laconique:

    String content;
    try (Scanner scanner = new Scanner(textFile).useDelimiter("\\Z")) {
        content = scanner.next();
    }

Le motif \Z indique au Scanner que le délimiteur est EOF.

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

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

   Testé pour fonctionner en 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 en Java 8 et 9 mais ne fonctionnera pas en Java 7 à cause de l'expression lambda exigence.

   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);
         });
       }
     }
   }
   

Je ne le vois pas encore mentionné dans les autres réponses jusqu'à présent. Mais si "Meilleur" signifie vitesse, alors la nouvelle E/S Java (NIO) pourrait fournir la préformance 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

Le moyen Le plus simple pour lire des données à partir d'un fichier en Java, faisant usage de la Fichier classe pour lire le fichier et le Scanner classe pour lire le contenu du fichier.

public static void main(String args[])throws Exception
{
   File f = new File("input.txt");
   takeInputIn2DArray(f);
}

public static void takeInputIn2DArray(File f) throws Exception
{
    Scanner s = new Scanner(f);
    int a[][] = new int[20][20];
    for(int i=0; i<20; i++)
    {
        for(int j=0; j<20; j++)
        {
            a[i][j] = s.nextInt();
        }
    }
}

PS: N'oubliez pas d'importer java.util.* ; pour scanner à travailler.

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 d'accès à 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 exécutez-le avec:

java InputReader < input.txt

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

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

java InputReader < input.txt > output.txt

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

Pour les applications Web Maven basées sur JSF, utilisez simplement ClassLoader et le dossier Resources pour lire dans le fichier de votre choix:

1. Placez n'importe quel fichier que vous souhaitez lire dans le dossier Ressources.

2. Mettez la dépendance Apache Commons IO dans votre POM:

   <dependency>
       <groupId>org.apache.commons</groupId>
       <artifactId>commons-io</artifactId>
       <version>1.3.2</version>
   </dependency>
   

3. Utilisez le code ci-dessous pour le lire (par exemple, ci-dessous lit dans a.fichier json):

   String metadata = null;
   FileInputStream inputStream;
   try {
   
       ClassLoader loader = Thread.currentThread().getContextClassLoader();
       inputStream = (FileInputStream) loader
               .getResourceAsStream("/metadata.json");
       metadata = IOUtils.toString(inputStream);
       inputStream.close();
   }
   catch (FileNotFoundException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
   }
   catch (IOException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
   }
   return metadata;
   

Vous pouvez faire la même chose pour les fichiers texte, .fichiers de propriétés, schémas XSD , etc.

Goyave fournit un one-liner pour cela:

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

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

Cactoos vous donne un one-liner déclaratif:

new TextOf(new File("a.txt")).asString();

Vous pouvez utiliser readAllLines et la méthode join pour obtenir tout le contenu du fichier en une seule ligne:

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

Il utilise l'encodage UTF-8 par défaut, 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 la nouvelle ligne peut également être \r\n. C'est en fonction de vos besoins qui convient.

Utilisez Java kiss s'il s'agit de simplicité de structure:

import static kiss.API.*;

class App {
  void run() {
    String line;
    try (Close in = inOpen("file.dat")) {
      while ((line = readLine()) != null) {
        println(line);
      }
    }
  }
}

Les classes de flux tamponnés sont beaucoup plus performantes dans la pratique, à tel point que le NIO.2 API inclut des méthodes qui renvoient spécifiquement ces classes de flux, en partie pour vous encourager à toujours utiliser des flux tamponnés dans votre application.

Voici un exemple:

Path path = Paths.get("/myfolder/myfile.ext");
    try (BufferedReader reader = Files.newBufferedReader(path)) {
        // Read from the stream
        String currentLine = null;
        while ((currentLine = reader.readLine()) != null)
            //do your code here
    } catch (IOException e) {
        // Handle file I/O exception...
    }

, Vous pouvez remplacer ce code

BufferedReader reader = Files.newBufferedReader(path);

Avec

BufferedReader br = new BufferedReader(new FileReader("/myfolder/myfile.ext"));

Je recommande cet article pour apprendre les principales utilisations de Java NIO et IO.

Ce code que j'ai programmé est beaucoup plus rapide pour les fichiers très volumineux:

public String readDoc(File f) {
    String text = "";
    int read, N = 1024 * 1024;
    char[] buffer = new char[N];

    try {
        FileReader fr = new FileReader(f);
        BufferedReader br = new BufferedReader(fr);

        while(true) {
            read = br.read(buffer, 0, N);
            text += new String(buffer, 0, read);

            if(read < N) {
                break;
            }
        }
    } catch(Exception ex) {
        ex.printStackTrace();
    }

    return text;
}